inline fun <T, K, R, M : MutableMap<in K, R>> Grouping<T, K>.aggregateTo(destination: M, operation: (key: K, accumulator: R?, element: T, first: Boolean) -> R): M

all

inline fun <T> Array<out T>.all(predicate: (T) -> Boolean): Boolean

inline fun BooleanArray.all(predicate: (Boolean) -> Boolean): Boolean

inline fun ByteArray.all(predicate: (Byte) -> Boolean): Boolean

inline fun CharArray.all(predicate: (Char) -> Boolean): Boolean

inline fun DoubleArray.all(predicate: (Double) -> Boolean): Boolean

inline fun FloatArray.all(predicate: (Float) -> Boolean): Boolean

inline fun IntArray.all(predicate: (Int) -> Boolean): Boolean

inline fun LongArray.all(predicate: (Long) -> Boolean): Boolean

inline fun ShortArray.all(predicate: (Short) -> Boolean): Boolean

@ExperimentalUnsignedTypes

inline fun UByteArray.all(predicate: (UByte) -> Boolean): Boolean

@ExperimentalUnsignedTypes

inline fun UIntArray.all(predicate: (UInt) -> Boolean): Boolean

@ExperimentalUnsignedTypes

inline fun ULongArray.all(predicate: (ULong) -> Boolean): Boolean

@ExperimentalUnsignedTypes

inline fun UShortArray.all(predicate: (UShort) -> Boolean): Boolean

inline fun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean

inline fun <K, V> Map<out K, V>.all(predicate: (Map.Entry<K, V>) -> Boolean): Boolean

any

fun <T> Array<out T>.any(): Boolean

fun BooleanArray.any(): Boolean

fun ByteArray.any(): Boolean

fun CharArray.any(): Boolean

fun DoubleArray.any(): Boolean

fun FloatArray.any(): Boolean

fun IntArray.any(): Boolean

fun LongArray.any(): Boolean

fun ShortArray.any(): Boolean

@ExperimentalUnsignedTypes

inline fun UByteArray.any(): Boolean

@ExperimentalUnsignedTypes

inline fun UIntArray.any(): Boolean

@ExperimentalUnsignedTypes

inline fun ULongArray.any(): Boolean

@ExperimentalUnsignedTypes

inline fun UShortArray.any(): Boolean

fun <T> Iterable<T>.any(): Boolean

fun <K, V> Map<out K, V>.any(): Boolean

inline fun <T> Array<out T>.any(predicate: (T) -> Boolean): Boolean

inline fun BooleanArray.any(predicate: (Boolean) -> Boolean): Boolean

inline fun ByteArray.any(predicate: (Byte) -> Boolean): Boolean

inline fun CharArray.any(predicate: (Char) -> Boolean): Boolean

inline fun DoubleArray.any(predicate: (Double) -> Boolean): Boolean

inline fun FloatArray.any(predicate: (Float) -> Boolean): Boolean

inline fun IntArray.any(predicate: (Int) -> Boolean): Boolean

inline fun LongArray.any(predicate: (Long) -> Boolean): Boolean

inline fun ShortArray.any(predicate: (Short) -> Boolean): Boolean

@ExperimentalUnsignedTypes

inline fun UByteArray.any(predicate: (UByte) -> Boolean): Boolean

@ExperimentalUnsignedTypes

inline fun UIntArray.any(predicate: (UInt) -> Boolean): Boolean

@ExperimentalUnsignedTypes

inline fun ULongArray.any(predicate: (ULong) -> Boolean): Boolean

@ExperimentalUnsignedTypes

inline fun UShortArray.any(predicate: (UShort) -> Boolean): Boolean

inline fun <T> Iterable<T>.any(predicate: (T) -> Boolean): Boolean

inline fun <K, V> Map<out K, V>.any(predicate: (Map.Entry<K, V>) -> Boolean): Boolean

arrayListOf

inline fun <T> arrayListOf(): ArrayList<T>

fun <T> arrayListOf(vararg elements: T): ArrayList<T>

asByteArray

@ExperimentalUnsignedTypes

inline fun UByteArray.asByteArray(): ByteArray

asIntArray

@ExperimentalUnsignedTypes

inline fun UIntArray.asIntArray(): IntArray

asIterable

fun <T> Array<out T>.asIterable(): Iterable<T>

fun BooleanArray.asIterable(): Iterable<Boolean>

fun ByteArray.asIterable(): Iterable<Byte>

fun CharArray.asIterable(): Iterable<Char>

fun DoubleArray.asIterable(): Iterable<Double>

fun FloatArray.asIterable(): Iterable<Float>

fun IntArray.asIterable(): Iterable<Int>

fun LongArray.asIterable(): Iterable<Long>

fun ShortArray.asIterable(): Iterable<Short>

inline fun <T> Iterable<T>.asIterable(): Iterable<T>

inline fun <K, V> Map<out K, V>.asIterable(): Iterable<Map.Entry<K, V>>

asList

fun <T> Array<out T>.asList(): List<T>

inline fun BooleanArray.asList(): List<Boolean>

inline fun ByteArray.asList(): List<Byte>

fun CharArray.asList(): List<Char>

inline fun DoubleArray.asList(): List<Double>

inline fun FloatArray.asList(): List<Float>

inline fun IntArray.asList(): List<Int>

inline fun LongArray.asList(): List<Long>

inline fun ShortArray.asList(): List<Short>

@ExperimentalUnsignedTypes

fun UByteArray.asList(): List<UByte>

@ExperimentalUnsignedTypes

fun UIntArray.asList(): List<UInt>

@ExperimentalUnsignedTypes

fun ULongArray.asList(): List<ULong>

@ExperimentalUnsignedTypes

fun UShortArray.asList(): List<UShort>

asLongArray

@ExperimentalUnsignedTypes

inline fun ULongArray.asLongArray(): LongArray

asReversed

fun <T> List<T>.asReversed(): List<T>

@JvmName(name = "asReversedMutable")

fun <T> MutableList<T>.asReversed(): MutableList<T>

asSequence

fun <T> Array<out T>.asSequence(): Sequence<T>

fun BooleanArray.asSequence(): Sequence<Boolean>

fun ByteArray.asSequence(): Sequence<Byte>

fun CharArray.asSequence(): Sequence<Char>

fun DoubleArray.asSequence(): Sequence<Double>

fun FloatArray.asSequence(): Sequence<Float>

fun IntArray.asSequence(): Sequence<Int>

fun LongArray.asSequence(): Sequence<Long>

fun ShortArray.asSequence(): Sequence<Short>

fun <T> Iterable<T>.asSequence(): Sequence<T>

fun <K, V> Map<out K, V>.asSequence(): Sequence<Map.Entry<K, V>>

asShortArray

@ExperimentalUnsignedTypes

inline fun UShortArray.asShortArray(): ShortArray

associate

inline fun <T, K, V> Array<out T>.associate(transform: (T) -> Pair<K, V>): Map<K, V>

inline fun <K, V> BooleanArray.associate(transform: (Boolean) -> Pair<K, V>): Map<K, V>

inline fun <K, V> ByteArray.associate(transform: (Byte) -> Pair<K, V>): Map<K, V>

inline fun <K, V> CharArray.associate(transform: (Char) -> Pair<K, V>): Map<K, V>

inline fun <K, V> DoubleArray.associate(transform: (Double) -> Pair<K, V>): Map<K, V>

inline fun <K, V> FloatArray.associate(transform: (Float) -> Pair<K, V>): Map<K, V>

inline fun <K, V> IntArray.associate(transform: (Int) -> Pair<K, V>): Map<K, V>

inline fun <K, V> LongArray.associate(transform: (Long) -> Pair<K, V>): Map<K, V>

inline fun <K, V> ShortArray.associate(transform: (Short) -> Pair<K, V>): Map<K, V>

inline fun <T, K, V> Iterable<T>.associate(transform: (T) -> Pair<K, V>): Map<K, V>

associateBy

inline fun <T, K> Array<out T>.associateBy(keySelector: (T) -> K): Map<K, T>

inline fun <K> BooleanArray.associateBy(keySelector: (Boolean) -> K): Map<K, Boolean>

inline fun <K> ByteArray.associateBy(keySelector: (Byte) -> K): Map<K, Byte>

inline fun <K> CharArray.associateBy(keySelector: (Char) -> K): Map<K, Char>

inline fun <K> DoubleArray.associateBy(keySelector: (Double) -> K): Map<K, Double>

inline fun <K> FloatArray.associateBy(keySelector: (Float) -> K): Map<K, Float>

inline fun <K> IntArray.associateBy(keySelector: (Int) -> K): Map<K, Int>

inline fun <K> LongArray.associateBy(keySelector: (Long) -> K): Map<K, Long>

inline fun <K> ShortArray.associateBy(keySelector: (Short) -> K): Map<K, Short>

inline fun <T, K> Iterable<T>.associateBy(keySelector: (T) -> K): Map<K, T>

inline fun <T, K, V> Array<out T>.associateBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, V>

inline fun <K, V> BooleanArray.associateBy(keySelector: (Boolean) -> K, valueTransform: (Boolean) -> V): Map<K, V>

inline fun <K, V> ByteArray.associateBy(keySelector: (Byte) -> K, valueTransform: (Byte) -> V): Map<K, V>

inline fun <K, V> CharArray.associateBy(keySelector: (Char) -> K, valueTransform: (Char) -> V): Map<K, V>

inline fun <K, V> DoubleArray.associateBy(keySelector: (Double) -> K, valueTransform: (Double) -> V): Map<K, V>

inline fun <K, V> FloatArray.associateBy(keySelector: (Float) -> K, valueTransform: (Float) -> V): Map<K, V>

inline fun <K, V> IntArray.associateBy(keySelector: (Int) -> K, valueTransform: (Int) -> V): Map<K, V>

inline fun <K, V> LongArray.associateBy(keySelector: (Long) -> K, valueTransform: (Long) -> V): Map<K, V>

inline fun <K, V> ShortArray.associateBy(keySelector: (Short) -> K, valueTransform: (Short) -> V): Map<K, V>

inline fun <T, K, V> Iterable<T>.associateBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, V>

associateByTo

inline fun <T, K, M : MutableMap<in K, in T>> Array<out T>.associateByTo(destination: M, keySelector: (T) -> K): M

inline fun <K, M : MutableMap<in K, in Boolean>> BooleanArray.associateByTo(destination: M, keySelector: (Boolean) -> K): M

inline fun <K, M : MutableMap<in K, in Byte>> ByteArray.associateByTo(destination: M, keySelector: (Byte) -> K): M

inline fun <K, M : MutableMap<in K, in Char>> CharArray.associateByTo(destination: M, keySelector: (Char) -> K): M

inline fun <K, M : MutableMap<in K, in Double>> DoubleArray.associateByTo(destination: M, keySelector: (Double) -> K): M

inline fun <K, M : MutableMap<in K, in Float>> FloatArray.associateByTo(destination: M, keySelector: (Float) -> K): M

inline fun <K, M : MutableMap<in K, in Int>> IntArray.associateByTo(destination: M, keySelector: (Int) -> K): M

inline fun <K, M : MutableMap<in K, in Long>> LongArray.associateByTo(destination: M, keySelector: (Long) -> K): M

inline fun <K, M : MutableMap<in K, in Short>> ShortArray.associateByTo(destination: M, keySelector: (Short) -> K): M

inline fun <T, K, M : MutableMap<in K, in T>> Iterable<T>.associateByTo(destination: M, keySelector: (T) -> K): M

inline fun <T, K, V, M : MutableMap<in K, in V>> Array<out T>.associateByTo( destination: M, keySelector: (T) -> K, valueTransform: (T) -> V): M

inline fun <K, V, M : MutableMap<in K, in V>> BooleanArray.associateByTo( destination: M, keySelector: (Boolean) -> K, valueTransform: (Boolean) -> V): M

inline fun <K, V, M : MutableMap<in K, in V>> ByteArray.associateByTo( destination: M, keySelector: (Byte) -> K, valueTransform: (Byte) -> V): M

inline fun <K, V, M : MutableMap<in K, in V>> CharArray.associateByTo( destination: M, keySelector: (Char) -> K, valueTransform: (Char) -> V): M

inline fun <K, V, M : MutableMap<in K, in V>> DoubleArray.associateByTo( destination: M, keySelector: (Double) -> K, valueTransform: (Double) -> V): M

inline fun <K, V, M : MutableMap<in K, in V>> FloatArray.associateByTo( destination: M, keySelector: (Float) -> K, valueTransform: (Float) -> V): M

inline fun <K, V, M : MutableMap<in K, in V>> IntArray.associateByTo( destination: M, keySelector: (Int) -> K, valueTransform: (Int) -> V): M

inline fun <K, V, M : MutableMap<in K, in V>> LongArray.associateByTo( destination: M, keySelector: (Long) -> K, valueTransform: (Long) -> V): M

inline fun <K, V, M : MutableMap<in K, in V>> ShortArray.associateByTo( destination: M, keySelector: (Short) -> K, valueTransform: (Short) -> V): M

inline fun <T, K, V, M : MutableMap<in K, in V>> Iterable<T>.associateByTo( destination: M, keySelector: (T) -> K, valueTransform: (T) -> V): M

associateTo

inline fun <T, K, V, M : MutableMap<in K, in V>> Array<out T>.associateTo(destination: M, transform: (T) -> Pair<K, V>): M

inline fun <K, V, M : MutableMap<in K, in V>> BooleanArray.associateTo(destination: M, transform: (Boolean) -> Pair<K, V>): M

inline fun <K, V, M : MutableMap<in K, in V>> ByteArray.associateTo(destination: M, transform: (Byte) -> Pair<K, V>): M

inline fun <K, V, M : MutableMap<in K, in V>> CharArray.associateTo(destination: M, transform: (Char) -> Pair<K, V>): M

inline fun <K, V, M : MutableMap<in K, in V>> DoubleArray.associateTo(destination: M, transform: (Double) -> Pair<K, V>): M

inline fun <K, V, M : MutableMap<in K, in V>> FloatArray.associateTo(destination: M, transform: (Float) -> Pair<K, V>): M

inline fun <K, V, M : MutableMap<in K, in V>> IntArray.associateTo(destination: M, transform: (Int) -> Pair<K, V>): M

inline fun <K, V, M : MutableMap<in K, in V>> LongArray.associateTo(destination: M, transform: (Long) -> Pair<K, V>): M

inline fun <K, V, M : MutableMap<in K, in V>> ShortArray.associateTo(destination: M, transform: (Short) -> Pair<K, V>): M

inline fun <T, K, V, M : MutableMap<in K, in V>> Iterable<T>.associateTo(destination: M, transform: (T) -> Pair<K, V>): M

associateWith

inline fun <K, V> Array<out K>.associateWith(valueSelector: (K) -> V): Map<K, V>

inline fun <V> BooleanArray.associateWith(valueSelector: (Boolean) -> V): Map<Boolean, V>

inline fun <V> ByteArray.associateWith(valueSelector: (Byte) -> V): Map<Byte, V>

inline fun <V> CharArray.associateWith(valueSelector: (Char) -> V): Map<Char, V>

inline fun <V> DoubleArray.associateWith(valueSelector: (Double) -> V): Map<Double, V>

inline fun <V> FloatArray.associateWith(valueSelector: (Float) -> V): Map<Float, V>

inline fun <V> IntArray.associateWith(valueSelector: (Int) -> V): Map<Int, V>

inline fun <V> LongArray.associateWith(valueSelector: (Long) -> V): Map<Long, V>

inline fun <V> ShortArray.associateWith(valueSelector: (Short) -> V): Map<Short, V>

@ExperimentalUnsignedTypes

inline fun <V> UByteArray.associateWith(valueSelector: (UByte) -> V): Map<UByte, V>

@ExperimentalUnsignedTypes

inline fun <V> UIntArray.associateWith(valueSelector: (UInt) -> V): Map<UInt, V>

@ExperimentalUnsignedTypes

inline fun <V> ULongArray.associateWith(valueSelector: (ULong) -> V): Map<ULong, V>

@ExperimentalUnsignedTypes

inline fun <V> UShortArray.associateWith(valueSelector: (UShort) -> V): Map<UShort, V>

inline fun <K, V> Iterable<K>.associateWith(valueSelector: (K) -> V): Map<K, V>

associateWithTo

inline fun <K, V, M : MutableMap<in K, in V>> Array<out K>.associateWithTo(destination: M, valueSelector: (K) -> V): M

inline fun <V, M : MutableMap<in Boolean, in V>> BooleanArray.associateWithTo(destination: M, valueSelector: (Boolean) -> V): M

inline fun <V, M : MutableMap<in Byte, in V>> ByteArray.associateWithTo(destination: M, valueSelector: (Byte) -> V): M

inline fun <V, M : MutableMap<in Char, in V>> CharArray.associateWithTo(destination: M, valueSelector: (Char) -> V): M

inline fun <V, M : MutableMap<in Double, in V>> DoubleArray.associateWithTo(destination: M, valueSelector: (Double) -> V): M

inline fun <V, M : MutableMap<in Float, in V>> FloatArray.associateWithTo(destination: M, valueSelector: (Float) -> V): M

inline fun <V, M : MutableMap<in Int, in V>> IntArray.associateWithTo(destination: M, valueSelector: (Int) -> V): M

inline fun <V, M : MutableMap<in Long, in V>> LongArray.associateWithTo(destination: M, valueSelector: (Long) -> V): M

inline fun <V, M : MutableMap<in Short, in V>> ShortArray.associateWithTo(destination: M, valueSelector: (Short) -> V): M

@ExperimentalUnsignedTypes

inline fun <V, M : MutableMap<in UByte, in V>> UByteArray.associateWithTo(destination: M, valueSelector: (UByte) -> V): M

@ExperimentalUnsignedTypes

inline fun <V, M : MutableMap<in UInt, in V>> UIntArray.associateWithTo(destination: M, valueSelector: (UInt) -> V): M

@ExperimentalUnsignedTypes

inline fun <V, M : MutableMap<in ULong, in V>> ULongArray.associateWithTo(destination: M, valueSelector: (ULong) -> V): M

@ExperimentalUnsignedTypes

inline fun <V, M : MutableMap<in UShort, in V>> UShortArray.associateWithTo(destination: M, valueSelector: (UShort) -> V): M

inline fun <K, V, M : MutableMap<in K, in V>> Iterable<K>.associateWithTo(destination: M, valueSelector: (K) -> V): M

asUByteArray

@ExperimentalUnsignedTypes

inline fun ByteArray.asUByteArray(): UByteArray

asUIntArray

@ExperimentalUnsignedTypes

inline fun IntArray.asUIntArray(): UIntArray

asULongArray

@ExperimentalUnsignedTypes

inline fun LongArray.asULongArray(): ULongArray

asUShortArray

@ExperimentalUnsignedTypes

inline fun ShortArray.asUShortArray(): UShortArray

average

@JvmName(name = "averageOfByte")

fun ByteArray.average(): Double

@JvmName(name = "averageOfDouble")

fun DoubleArray.average(): Double

@JvmName(name = "averageOfFloat")

fun FloatArray.average(): Double

@JvmName(name = "averageOfInt")

fun IntArray.average(): Double

@JvmName(name = "averageOfLong")

fun LongArray.average(): Double

@JvmName(name = "averageOfShort")

fun ShortArray.average(): Double

fun ByteArray.average(): Double

fun DoubleArray.average(): Double

fun FloatArray.average(): Double

fun IntArray.average(): Double

fun LongArray.average(): Double

fun ShortArray.average(): Double

@JvmName(name = "averageOfByte")

fun Iterable<Byte>.average(): Double

@JvmName(name = "averageOfDouble")

fun Iterable<Double>.average(): Double

@JvmName(name = "averageOfFloat")

fun Iterable<Float>.average(): Double

@JvmName(name = "averageOfInt")

fun Iterable<Int>.average(): Double

@JvmName(name = "averageOfLong")

fun Iterable<Long>.average(): Double

@JvmName(name = "averageOfShort")

fun Iterable<Short>.average(): Double

binarySearch

fun <T> List<T>.binarySearch(fromIndex: Int)

fun <T : Comparable<T>> List<T?>.binarySearch(element: T?, fromIndex: Int)

fun <T> List<T>.binarySearch( element: T, comparator: Comparator<in T>, fromIndex: Int)

binarySearchBy

inline fun <T, K : Comparable<K>> List<T>.binarySearchBy(key: K?, fromIndex: Int)

buildList

inline fun <E> buildList(builderAction: MutableList<E>.() -> Unit): List<E>

inline fun <E> buildList(capacity: Int, builderAction: MutableList<E>.() -> Unit): List<E>

buildMap

inline fun <K, V> buildMap(builderAction: MutableMap<K, V>.() -> Unit): Map<K, V>

inline fun <K, V> buildMap(capacity: Int, builderAction: MutableMap<K, V>.() -> Unit): Map<K, V>

buildSet

inline fun <E> buildSet(builderAction: MutableSet<E>.() -> Unit): Set<E>

inline fun <E> buildSet(capacity: Int, builderAction: MutableSet<E>.() -> Unit): Set<E>

chunked

fun <T> Iterable<T>.chunked(size: Int): List<List<T>>

fun <T, R> Iterable<T>.chunked(size: Int, transform: (List<T>) -> R): List<R>

component1

inline operator fun <T> Array<out T>.component1(): T

inline operator fun BooleanArray.component1(): Boolean

inline operator fun ByteArray.component1(): Byte

inline operator fun CharArray.component1(): Char

inline operator fun DoubleArray.component1(): Double

inline operator fun FloatArray.component1(): Float

inline operator fun IntArray.component1(): Int

inline operator fun LongArray.component1(): Long

inline operator fun ShortArray.component1(): Short

@ExperimentalUnsignedTypes

inline operator fun UByteArray.component1(): UByte

@ExperimentalUnsignedTypes

inline operator fun UIntArray.component1(): UInt

@ExperimentalUnsignedTypes

inline operator fun ULongArray.component1(): ULong

@ExperimentalUnsignedTypes

inline operator fun UShortArray.component1(): UShort

inline operator fun <T> List<T>.component1(): T

inline operator fun <K, V> Map.Entry<K, V>.component1(): K

component2

inline operator fun <T> Array<out T>.component2(): T

inline operator fun BooleanArray.component2(): Boolean

inline operator fun ByteArray.component2(): Byte

inline operator fun CharArray.component2(): Char

inline operator fun DoubleArray.component2(): Double

inline operator fun FloatArray.component2(): Float

inline operator fun IntArray.component2(): Int

inline operator fun LongArray.component2(): Long

inline operator fun ShortArray.component2(): Short

@ExperimentalUnsignedTypes

inline operator fun UByteArray.component2(): UByte

@ExperimentalUnsignedTypes

inline operator fun UIntArray.component2(): UInt

@ExperimentalUnsignedTypes

inline operator fun ULongArray.component2(): ULong

@ExperimentalUnsignedTypes

inline operator fun UShortArray.component2(): UShort

inline operator fun <T> List<T>.component2(): T

inline operator fun <K, V> Map.Entry<K, V>.component2(): V

component3

inline operator fun <T> Array<out T>.component3(): T

inline operator fun BooleanArray.component3(): Boolean

inline operator fun ByteArray.component3(): Byte

inline operator fun CharArray.component3(): Char

inline operator fun DoubleArray.component3(): Double

inline operator fun FloatArray.component3(): Float

inline operator fun IntArray.component3(): Int

inline operator fun LongArray.component3(): Long

inline operator fun ShortArray.component3(): Short

@ExperimentalUnsignedTypes

inline operator fun UByteArray.component3(): UByte

@ExperimentalUnsignedTypes

inline operator fun UIntArray.component3(): UInt

@ExperimentalUnsignedTypes

inline operator fun ULongArray.component3(): ULong

@ExperimentalUnsignedTypes

inline operator fun UShortArray.component3(): UShort

inline operator fun <T> List<T>.component3(): T

component4

inline operator fun <T> Array<out T>.component4(): T

inline operator fun BooleanArray.component4(): Boolean

inline operator fun ByteArray.component4(): Byte

inline operator fun CharArray.component4(): Char

inline operator fun DoubleArray.component4(): Double

inline operator fun FloatArray.component4(): Float

inline operator fun IntArray.component4(): Int

inline operator fun LongArray.component4(): Long

inline operator fun ShortArray.component4(): Short

@ExperimentalUnsignedTypes

inline operator fun UByteArray.component4(): UByte

@ExperimentalUnsignedTypes

inline operator fun UIntArray.component4(): UInt

@ExperimentalUnsignedTypes

inline operator fun ULongArray.component4(): ULong

@ExperimentalUnsignedTypes

inline operator fun UShortArray.component4(): UShort

inline operator fun <T> List<T>.component4(): T

component5

inline operator fun <T> Array<out T>.component5(): T

inline operator fun BooleanArray.component5(): Boolean

inline operator fun ByteArray.component5(): Byte

inline operator fun CharArray.component5(): Char

inline operator fun DoubleArray.component5(): Double

inline operator fun FloatArray.component5(): Float

inline operator fun IntArray.component5(): Int

inline operator fun LongArray.component5(): Long

inline operator fun ShortArray.component5(): Short

@ExperimentalUnsignedTypes

inline operator fun UByteArray.component5(): UByte

@ExperimentalUnsignedTypes

inline operator fun UIntArray.component5(): UInt

@ExperimentalUnsignedTypes

inline operator fun ULongArray.component5(): ULong

@ExperimentalUnsignedTypes

inline operator fun UShortArray.component5(): UShort

inline operator fun <T> List<T>.component5(): T

contains

operator fun <T> Array<out T>.contains(element: T): Boolean

operator fun BooleanArray.contains(element: Boolean): Boolean

operator fun ByteArray.contains(element: Byte): Boolean

operator fun CharArray.contains(element: Char): Boolean

@DeprecatedSinceKotlin(errorSince = "1.6", hiddenSince = "1.7", warningSince = "1.4")

~~operator~~ ~~fun~~ DoubleArray.~~contains~~(element: Double): Boolean

@DeprecatedSinceKotlin(errorSince = "1.6", hiddenSince = "1.7", warningSince = "1.4")

~~operator~~ ~~fun~~ FloatArray.~~contains~~(element: Float): Boolean

operator fun IntArray.contains(element: Int): Boolean

operator fun LongArray.contains(element: Long): Boolean

operator fun ShortArray.contains(element: Short): Boolean

operator fun <T> Iterable<T>.contains(element: T): Boolean

inline operator fun <K, V> Map<out K, V>.contains(key: K): Boolean

containsAll

inline fun <T> Collection<T>.containsAll(elements: Collection<T>): Boolean

containsKey

inline fun <K> Map<out K, *>.containsKey(key: K): Boolean

containsValue

inline fun <K, V> Map<K, V>.containsValue(value: V): Boolean

contentDeepEquals

infix fun <T> Array<out T>.contentDeepEquals(other: Array<out T>): Boolean

infix fun <T> Array<out T>?.contentDeepEquals(other: Array<out T>?): Boolean

contentDeepHashCode

fun <T> Array<out T>.contentDeepHashCode(): Int

fun <T> Array<out T>?.contentDeepHashCode(): Int

contentDeepToString

fun <T> Array<out T>.contentDeepToString(): String

fun <T> Array<out T>?.contentDeepToString(): String

contentEquals

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~infix~~ ~~fun~~ <T> Array<out T>.~~contentEquals~~(other: Array<out T>): Boolean

infix fun <T> Array<out T>?.contentEquals(other: Array<out T>?): Boolean

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~infix~~ ~~fun~~ BooleanArray.~~contentEquals~~(other: BooleanArray): Boolean

infix fun BooleanArray?.contentEquals(other: BooleanArray?): Boolean

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~infix~~ ~~fun~~ ByteArray.~~contentEquals~~(other: ByteArray): Boolean

infix fun ByteArray?.contentEquals(other: ByteArray?): Boolean

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~infix~~ ~~fun~~ CharArray.~~contentEquals~~(other: CharArray): Boolean

infix fun CharArray?.contentEquals(other: CharArray?): Boolean

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~infix~~ ~~fun~~ DoubleArray.~~contentEquals~~(other: DoubleArray): Boolean

infix fun DoubleArray?.contentEquals(other: DoubleArray?): Boolean

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~infix~~ ~~fun~~ FloatArray.~~contentEquals~~(other: FloatArray): Boolean

infix fun FloatArray?.contentEquals(other: FloatArray?): Boolean

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~infix~~ ~~fun~~ IntArray.~~contentEquals~~(other: IntArray): Boolean

infix fun IntArray?.contentEquals(other: IntArray?): Boolean

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~infix~~ ~~fun~~ LongArray.~~contentEquals~~(other: LongArray): Boolean

infix fun LongArray?.contentEquals(other: LongArray?): Boolean

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~infix~~ ~~fun~~ ShortArray.~~contentEquals~~(other: ShortArray): Boolean

infix fun ShortArray?.contentEquals(other: ShortArray?): Boolean

@DeprecatedSinceKotlin(hiddenSince = "1.4")

@ExperimentalUnsignedTypes

~~infix~~ ~~fun~~ UByteArray.~~contentEquals~~(other: UByteArray): Boolean

@ExperimentalUnsignedTypes

infix fun UByteArray?.contentEquals(other: UByteArray?): Boolean

@DeprecatedSinceKotlin(hiddenSince = "1.4")

@ExperimentalUnsignedTypes

~~infix~~ ~~fun~~ UIntArray.~~contentEquals~~(other: UIntArray): Boolean

@ExperimentalUnsignedTypes

infix fun UIntArray?.contentEquals(other: UIntArray?): Boolean

@DeprecatedSinceKotlin(hiddenSince = "1.4")

@ExperimentalUnsignedTypes

~~infix~~ ~~fun~~ ULongArray.~~contentEquals~~(other: ULongArray): Boolean

@ExperimentalUnsignedTypes

infix fun ULongArray?.contentEquals(other: ULongArray?): Boolean

@DeprecatedSinceKotlin(hiddenSince = "1.4")

@ExperimentalUnsignedTypes

~~infix~~ ~~fun~~ UShortArray.~~contentEquals~~(other: UShortArray): Boolean

@ExperimentalUnsignedTypes

infix fun UShortArray?.contentEquals(other: UShortArray?): Boolean

contentHashCode

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~fun~~ <T> Array<out T>.~~contentHashCode~~(): Int

fun <T> Array<out T>?.contentHashCode(): Int

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~fun~~ BooleanArray.~~contentHashCode~~(): Int

fun BooleanArray?.contentHashCode(): Int

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~fun~~ ByteArray.~~contentHashCode~~(): Int

fun ByteArray?.contentHashCode(): Int

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~fun~~ CharArray.~~contentHashCode~~(): Int

fun CharArray?.contentHashCode(): Int

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~fun~~ DoubleArray.~~contentHashCode~~(): Int

fun DoubleArray?.contentHashCode(): Int

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~fun~~ FloatArray.~~contentHashCode~~(): Int

fun FloatArray?.contentHashCode(): Int

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~fun~~ IntArray.~~contentHashCode~~(): Int

fun IntArray?.contentHashCode(): Int

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~fun~~ LongArray.~~contentHashCode~~(): Int

fun LongArray?.contentHashCode(): Int

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~fun~~ ShortArray.~~contentHashCode~~(): Int

fun ShortArray?.contentHashCode(): Int

@DeprecatedSinceKotlin(hiddenSince = "1.4")

@ExperimentalUnsignedTypes

~~fun~~ UByteArray.~~contentHashCode~~(): Int

@ExperimentalUnsignedTypes

fun UByteArray?.contentHashCode(): Int

@DeprecatedSinceKotlin(hiddenSince = "1.4")

@ExperimentalUnsignedTypes

~~fun~~ UIntArray.~~contentHashCode~~(): Int

@ExperimentalUnsignedTypes

fun UIntArray?.contentHashCode(): Int

@DeprecatedSinceKotlin(hiddenSince = "1.4")

@ExperimentalUnsignedTypes

~~fun~~ ULongArray.~~contentHashCode~~(): Int

@ExperimentalUnsignedTypes

fun ULongArray?.contentHashCode(): Int

@DeprecatedSinceKotlin(hiddenSince = "1.4")

@ExperimentalUnsignedTypes

~~fun~~ UShortArray.~~contentHashCode~~(): Int

@ExperimentalUnsignedTypes

fun UShortArray?.contentHashCode(): Int

contentToString

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~fun~~ <T> Array<out T>.~~contentToString~~(): String

fun <T> Array<out T>?.contentToString(): String

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~fun~~ BooleanArray.~~contentToString~~(): String

fun BooleanArray?.contentToString(): String

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~fun~~ ByteArray.~~contentToString~~(): String

fun ByteArray?.contentToString(): String

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~fun~~ CharArray.~~contentToString~~(): String

fun CharArray?.contentToString(): String

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~fun~~ DoubleArray.~~contentToString~~(): String

fun DoubleArray?.contentToString(): String

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~fun~~ FloatArray.~~contentToString~~(): String

fun FloatArray?.contentToString(): String

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~fun~~ IntArray.~~contentToString~~(): String

fun IntArray?.contentToString(): String

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~fun~~ LongArray.~~contentToString~~(): String

fun LongArray?.contentToString(): String

@DeprecatedSinceKotlin(hiddenSince = "1.4")

~~fun~~ ShortArray.~~contentToString~~(): String

fun ShortArray?.contentToString(): String

@DeprecatedSinceKotlin(hiddenSince = "1.4")

@ExperimentalUnsignedTypes

~~fun~~ UByteArray.~~contentToString~~(): String

@ExperimentalUnsignedTypes

fun UByteArray?.contentToString(): String

@DeprecatedSinceKotlin(hiddenSince = "1.4")

@ExperimentalUnsignedTypes

~~fun~~ UIntArray.~~contentToString~~(): String

@ExperimentalUnsignedTypes

fun UIntArray?.contentToString(): String

@DeprecatedSinceKotlin(hiddenSince = "1.4")

@ExperimentalUnsignedTypes

~~fun~~ ULongArray.~~contentToString~~(): String

@ExperimentalUnsignedTypes

fun ULongArray?.contentToString(): String

@DeprecatedSinceKotlin(hiddenSince = "1.4")

@ExperimentalUnsignedTypes

~~fun~~ UShortArray.~~contentToString~~(): String

@ExperimentalUnsignedTypes

fun UShortArray?.contentToString(): String

copyInto

inline fun <T> Array<out T>.copyInto(destination: Array<T>, destinationOffset: Int)

inline fun BooleanArray.copyInto(destination: BooleanArray, destinationOffset: Int)

inline fun ByteArray.copyInto(destination: ByteArray, destinationOffset: Int)

inline fun CharArray.copyInto(destination: CharArray, destinationOffset: Int)

inline fun DoubleArray.copyInto(destination: DoubleArray, destinationOffset: Int)

inline fun FloatArray.copyInto(destination: FloatArray, destinationOffset: Int)

inline fun IntArray.copyInto(destination: IntArray, destinationOffset: Int)

inline fun LongArray.copyInto(destination: LongArray, destinationOffset: Int)

inline fun ShortArray.copyInto(destination: ShortArray, destinationOffset: Int)

@ExperimentalUnsignedTypes

inline fun UByteArray.copyInto(destination: UByteArray, destinationOffset: Int)

@ExperimentalUnsignedTypes

inline fun UIntArray.copyInto(destination: UIntArray, destinationOffset: Int)

@ExperimentalUnsignedTypes

inline fun ULongArray.copyInto(destination: ULongArray, destinationOffset: Int)

@ExperimentalUnsignedTypes

inline fun UShortArray.copyInto(destination: UShortArray, destinationOffset: Int)

copyOf

inline fun <T> Array<out T>.copyOf(): Array<T>

fun BooleanArray.copyOf(): BooleanArray

inline fun ByteArray.copyOf(): ByteArray

fun CharArray.copyOf(): CharArray

inline fun DoubleArray.copyOf(): DoubleArray

inline fun FloatArray.copyOf(): FloatArray

inline fun IntArray.copyOf(): IntArray

fun LongArray.copyOf(): LongArray

inline fun ShortArray.copyOf(): ShortArray

@ExperimentalUnsignedTypes

inline fun UByteArray.copyOf(): UByteArray

@ExperimentalUnsignedTypes

inline fun UIntArray.copyOf(): UIntArray

@ExperimentalUnsignedTypes

inline fun ULongArray.copyOf(): ULongArray

@ExperimentalUnsignedTypes

inline fun UShortArray.copyOf(): UShortArray

fun <T> Array<out T>.copyOf(newSize: Int): Array<T?>

fun BooleanArray.copyOf(newSize: Int): BooleanArray

fun ByteArray.copyOf(newSize: Int): ByteArray

fun CharArray.copyOf(newSize: Int): CharArray

fun DoubleArray.copyOf(newSize: Int): DoubleArray

fun FloatArray.copyOf(newSize: Int): FloatArray

fun IntArray.copyOf(newSize: Int): IntArray

fun LongArray.copyOf(newSize: Int): LongArray

fun ShortArray.copyOf(newSize: Int): ShortArray

@ExperimentalUnsignedTypes

inline fun UByteArray.copyOf(newSize: Int): UByteArray

@ExperimentalUnsignedTypes

inline fun UIntArray.copyOf(newSize: Int): UIntArray

@ExperimentalUnsignedTypes

inline fun ULongArray.copyOf(newSize: Int): ULongArray

@ExperimentalUnsignedTypes

inline fun UShortArray.copyOf(newSize: Int): UShortArray

copyOfRange

fun <T> Array<out T>.copyOfRange(fromIndex: Int, toIndex: Int): Array<T>

fun BooleanArray.copyOfRange(fromIndex: Int, toIndex: Int): BooleanArray

fun ByteArray.copyOfRange(fromIndex: Int, toIndex: Int): ByteArray

fun CharArray.copyOfRange(fromIndex: Int, toIndex: Int): CharArray

fun DoubleArray.copyOfRange(fromIndex: Int, toIndex: Int): DoubleArray

fun FloatArray.copyOfRange(fromIndex: Int, toIndex: Int): FloatArray

fun IntArray.copyOfRange(fromIndex: Int, toIndex: Int): IntArray

fun LongArray.copyOfRange(fromIndex: Int, toIndex: Int): LongArray

fun ShortArray.copyOfRange(fromIndex: Int, toIndex: Int): ShortArray

@ExperimentalUnsignedTypes

inline fun UByteArray.copyOfRange(fromIndex: Int, toIndex: Int): UByteArray

@ExperimentalUnsignedTypes

inline fun UIntArray.copyOfRange(fromIndex: Int, toIndex: Int): UIntArray

@ExperimentalUnsignedTypes

inline fun ULongArray.copyOfRange(fromIndex: Int, toIndex: Int): ULongArray

@ExperimentalUnsignedTypes

inline fun UShortArray.copyOfRange(fromIndex: Int, toIndex: Int): UShortArray

count

inline fun <T> Array<out T>.count(): Int

inline fun BooleanArray.count(): Int

inline fun ByteArray.count(): Int

inline fun CharArray.count(): Int

inline fun DoubleArray.count(): Int

inline fun FloatArray.count(): Int

inline fun IntArray.count(): Int

inline fun LongArray.count(): Int

inline fun ShortArray.count(): Int

inline fun <T> Collection<T>.count(): Int

fun <T> Iterable<T>.count(): Int

inline fun <K, V> Map<out K, V>.count(): Int

inline fun <T> Array<out T>.count(predicate: (T) -> Boolean): Int

inline fun BooleanArray.count(predicate: (Boolean) -> Boolean): Int

inline fun ByteArray.count(predicate: (Byte) -> Boolean): Int

inline fun CharArray.count(predicate: (Char) -> Boolean): Int

inline fun DoubleArray.count(predicate: (Double) -> Boolean): Int

inline fun FloatArray.count(predicate: (Float) -> Boolean): Int

inline fun IntArray.count(predicate: (Int) -> Boolean): Int

inline fun LongArray.count(predicate: (Long) -> Boolean): Int

inline fun ShortArray.count(predicate: (Short) -> Boolean): Int

@ExperimentalUnsignedTypes

inline fun UByteArray.count(predicate: (UByte) -> Boolean): Int

@ExperimentalUnsignedTypes

inline fun UIntArray.count(predicate: (UInt) -> Boolean): Int

@ExperimentalUnsignedTypes

inline fun ULongArray.count(predicate: (ULong) -> Boolean): Int

@ExperimentalUnsignedTypes

inline fun UShortArray.count(predicate: (UShort) -> Boolean): Int

inline fun <T> Iterable<T>.count(predicate: (T) -> Boolean): Int

inline fun <K, V> Map<out K, V>.count(predicate: (Map.Entry<K, V>) -> Boolean): Int

distinct

fun <T> Array<out T>.distinct(): List<T>

fun BooleanArray.distinct(): List<Boolean>

fun ByteArray.distinct(): List<Byte>

fun CharArray.distinct(): List<Char>

fun DoubleArray.distinct(): List<Double>

fun FloatArray.distinct(): List<Float>

fun IntArray.distinct(): List<Int>

fun LongArray.distinct(): List<Long>

fun ShortArray.distinct(): List<Short>

fun <T> Iterable<T>.distinct(): List<T>

distinctBy

inline fun <T, K> Array<out T>.distinctBy(selector: (T) -> K): List<T>

inline fun <K> BooleanArray.distinctBy(selector: (Boolean) -> K): List<Boolean>

inline fun <K> ByteArray.distinctBy(selector: (Byte) -> K): List<Byte>

inline fun <K> CharArray.distinctBy(selector: (Char) -> K): List<Char>

inline fun <K> DoubleArray.distinctBy(selector: (Double) -> K): List<Double>

inline fun <K> FloatArray.distinctBy(selector: (Float) -> K): List<Float>

inline fun <K> IntArray.distinctBy(selector: (Int) -> K): List<Int>

inline fun <K> LongArray.distinctBy(selector: (Long) -> K): List<Long>

inline fun <K> ShortArray.distinctBy(selector: (Short) -> K): List<Short>

inline fun <T, K> Iterable<T>.distinctBy(selector: (T) -> K): List<T>

drop

fun <T> Array<out T>.drop(n: Int): List<T>

fun BooleanArray.drop(n: Int): List<Boolean>

fun ByteArray.drop(n: Int): List<Byte>

fun CharArray.drop(n: Int): List<Char>

fun DoubleArray.drop(n: Int): List<Double>

fun FloatArray.drop(n: Int): List<Float>

fun IntArray.drop(n: Int): List<Int>

fun LongArray.drop(n: Int): List<Long>

fun ShortArray.drop(n: Int): List<Short>

@ExperimentalUnsignedTypes

fun UByteArray.drop(n: Int): List<UByte>

@ExperimentalUnsignedTypes

fun UIntArray.drop(n: Int): List<UInt>

@ExperimentalUnsignedTypes

fun ULongArray.drop(n: Int): List<ULong>

@ExperimentalUnsignedTypes

fun UShortArray.drop(n: Int): List<UShort>

fun <T> Iterable<T>.drop(n: Int): List<T>

dropLast

fun <T> Array<out T>.dropLast(n: Int): List<T>

fun BooleanArray.dropLast(n: Int): List<Boolean>

fun ByteArray.dropLast(n: Int): List<Byte>

fun CharArray.dropLast(n: Int): List<Char>

fun DoubleArray.dropLast(n: Int): List<Double>

fun FloatArray.dropLast(n: Int): List<Float>

fun IntArray.dropLast(n: Int): List<Int>

fun LongArray.dropLast(n: Int): List<Long>

fun ShortArray.dropLast(n: Int): List<Short>

@ExperimentalUnsignedTypes

fun UByteArray.dropLast(n: Int): List<UByte>

@ExperimentalUnsignedTypes

fun UIntArray.dropLast(n: Int): List<UInt>

@ExperimentalUnsignedTypes

fun ULongArray.dropLast(n: Int): List<ULong>

@ExperimentalUnsignedTypes

fun UShortArray.dropLast(n: Int): List<UShort>

fun <T> List<T>.dropLast(n: Int): List<T>

dropLastWhile

inline fun <T> Array<out T>.dropLastWhile(predicate: (T) -> Boolean): List<T>

inline fun BooleanArray.dropLastWhile(predicate: (Boolean) -> Boolean): List<Boolean>

inline fun ByteArray.dropLastWhile(predicate: (Byte) -> Boolean): List<Byte>

inline fun CharArray.dropLastWhile(predicate: (Char) -> Boolean): List<Char>

inline fun DoubleArray.dropLastWhile(predicate: (Double) -> Boolean): List<Double>

inline fun FloatArray.dropLastWhile(predicate: (Float) -> Boolean): List<Float>

inline fun IntArray.dropLastWhile(predicate: (Int) -> Boolean): List<Int>

inline fun LongArray.dropLastWhile(predicate: (Long) -> Boolean): List<Long>

inline fun ShortArray.dropLastWhile(predicate: (Short) -> Boolean): List<Short>

@ExperimentalUnsignedTypes

inline fun UByteArray.dropLastWhile(predicate: (UByte) -> Boolean): List<UByte>

@ExperimentalUnsignedTypes

inline fun UIntArray.dropLastWhile(predicate: (UInt) -> Boolean): List<UInt>

@ExperimentalUnsignedTypes

inline fun ULongArray.dropLastWhile(predicate: (ULong) -> Boolean): List<ULong>

@ExperimentalUnsignedTypes

inline fun UShortArray.dropLastWhile(predicate: (UShort) -> Boolean): List<UShort>

inline fun <T> List<T>.dropLastWhile(predicate: (T) -> Boolean): List<T>

dropWhile

inline fun <T> Array<out T>.dropWhile(predicate: (T) -> Boolean): List<T>

inline fun BooleanArray.dropWhile(predicate: (Boolean) -> Boolean): List<Boolean>

inline fun ByteArray.dropWhile(predicate: (Byte) -> Boolean): List<Byte>

inline fun CharArray.dropWhile(predicate: (Char) -> Boolean): List<Char>

inline fun DoubleArray.dropWhile(predicate: (Double) -> Boolean): List<Double>

inline fun FloatArray.dropWhile(predicate: (Float) -> Boolean): List<Float>

inline fun IntArray.dropWhile(predicate: (Int) -> Boolean): List<Int>

inline fun LongArray.dropWhile(predicate: (Long) -> Boolean): List<Long>

inline fun ShortArray.dropWhile(predicate: (Short) -> Boolean): List<Short>

@ExperimentalUnsignedTypes

inline fun UByteArray.dropWhile(predicate: (UByte) -> Boolean): List<UByte>

@ExperimentalUnsignedTypes

inline fun UIntArray.dropWhile(predicate: (UInt) -> Boolean): List<UInt>

@ExperimentalUnsignedTypes

inline fun ULongArray.dropWhile(predicate: (ULong) -> Boolean): List<ULong>

@ExperimentalUnsignedTypes

inline fun UShortArray.dropWhile(predicate: (UShort) -> Boolean): List<UShort>

inline fun <T> Iterable<T>.dropWhile(predicate: (T) -> Boolean): List<T>

eachCount

fun <T, K> Grouping<T, K>.eachCount(): Map<K, Int>

eachCountTo

fun <T, K, M : MutableMap<in K, Int>> Grouping<T, K>.eachCountTo(destination: M): M

elementAt

fun <T> Array<out T>.elementAt(index: Int): T

fun BooleanArray.elementAt(index: Int): Boolean

fun ByteArray.elementAt(index: Int): Byte

fun CharArray.elementAt(index: Int): Char

fun DoubleArray.elementAt(index: Int): Double

fun FloatArray.elementAt(index: Int): Float

fun IntArray.elementAt(index: Int): Int

fun LongArray.elementAt(index: Int): Long

fun ShortArray.elementAt(index: Int): Short

@ExperimentalUnsignedTypes

fun UByteArray.elementAt(index: Int): UByte

@ExperimentalUnsignedTypes

fun UIntArray.elementAt(index: Int): UInt

@ExperimentalUnsignedTypes

fun ULongArray.elementAt(index: Int): ULong

@ExperimentalUnsignedTypes

fun UShortArray.elementAt(index: Int): UShort

fun <T> Iterable<T>.elementAt(index: Int): T

inline fun <T> List<T>.elementAt(index: Int): T

elementAtOrElse

inline fun <T> Array<out T>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T

inline fun BooleanArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Boolean): Boolean

inline fun ByteArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Byte): Byte

inline fun CharArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Char): Char

inline fun DoubleArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Double): Double

inline fun FloatArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Float): Float

inline fun IntArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Int): Int

inline fun LongArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Long): Long

inline fun ShortArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Short): Short

@ExperimentalUnsignedTypes

inline fun UByteArray.elementAtOrElse(index: Int, defaultValue: (Int) -> UByte): UByte

@ExperimentalUnsignedTypes

inline fun UIntArray.elementAtOrElse(index: Int, defaultValue: (Int) -> UInt): UInt

@ExperimentalUnsignedTypes

inline fun ULongArray.elementAtOrElse(index: Int, defaultValue: (Int) -> ULong): ULong

@ExperimentalUnsignedTypes

inline fun UShortArray.elementAtOrElse(index: Int, defaultValue: (Int) -> UShort): UShort

fun <T> Iterable<T>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T

inline fun <T> List<T>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T

elementAtOrNull

inline fun <T> Array<out T>.elementAtOrNull(index: Int): T?

inline fun BooleanArray.elementAtOrNull(index: Int): Boolean?

inline fun ByteArray.elementAtOrNull(index: Int): Byte?

inline fun CharArray.elementAtOrNull(index: Int): Char?

inline fun DoubleArray.elementAtOrNull(index: Int): Double?

inline fun FloatArray.elementAtOrNull(index: Int): Float?

inline fun IntArray.elementAtOrNull(index: Int): Int?

inline fun LongArray.elementAtOrNull(index: Int): Long?

inline fun ShortArray.elementAtOrNull(index: Int): Short?

@ExperimentalUnsignedTypes

inline fun UByteArray.elementAtOrNull(index: Int): UByte?

@ExperimentalUnsignedTypes

inline fun UIntArray.elementAtOrNull(index: Int): UInt?

@ExperimentalUnsignedTypes

inline fun ULongArray.elementAtOrNull(index: Int): ULong?

@ExperimentalUnsignedTypes

inline fun UShortArray.elementAtOrNull(index: Int): UShort?

fun <T> Iterable<T>.elementAtOrNull(index: Int): T?

inline fun <T> List<T>.elementAtOrNull(index: Int): T?

emptyList

fun <T> emptyList(): List<T>

emptyMap

fun <K, V> emptyMap(): Map<K, V>

emptySet

fun <T> emptySet(): Set<T>

fill

fun <T> MutableList<T>.fill(value: T)

fun <T> Array<T>.fill(element: T, fromIndex: Int)

fun BooleanArray.fill(element: Boolean, fromIndex: Int)

fun ByteArray.fill(element: Byte, fromIndex: Int)

fun CharArray.fill(element: Char, fromIndex: Int)

fun DoubleArray.fill(element: Double, fromIndex: Int)

fun FloatArray.fill(element: Float, fromIndex: Int)

fun IntArray.fill(element: Int, fromIndex: Int)

fun LongArray.fill(element: Long, fromIndex: Int)

fun ShortArray.fill(element: Short, fromIndex: Int)

@ExperimentalUnsignedTypes

fun UByteArray.fill(element: UByte, fromIndex: Int)

@ExperimentalUnsignedTypes

fun UIntArray.fill(element: UInt, fromIndex: Int)

@ExperimentalUnsignedTypes

fun ULongArray.fill(element: ULong, fromIndex: Int)

@ExperimentalUnsignedTypes

fun UShortArray.fill(element: UShort, fromIndex: Int)

filter

inline fun <T> Array<out T>.filter(predicate: (T) -> Boolean): List<T>

inline fun BooleanArray.filter(predicate: (Boolean) -> Boolean): List<Boolean>

inline fun ByteArray.filter(predicate: (Byte) -> Boolean): List<Byte>

inline fun CharArray.filter(predicate: (Char) -> Boolean): List<Char>

inline fun DoubleArray.filter(predicate: (Double) -> Boolean): List<Double>

inline fun FloatArray.filter(predicate: (Float) -> Boolean): List<Float>

inline fun IntArray.filter(predicate: (Int) -> Boolean): List<Int>

inline fun LongArray.filter(predicate: (Long) -> Boolean): List<Long>

inline fun ShortArray.filter(predicate: (Short) -> Boolean): List<Short>

@ExperimentalUnsignedTypes

inline fun UByteArray.filter(predicate: (UByte) -> Boolean): List<UByte>

@ExperimentalUnsignedTypes

inline fun UIntArray.filter(predicate: (UInt) -> Boolean): List<UInt>

@ExperimentalUnsignedTypes

inline fun ULongArray.filter(predicate: (ULong) -> Boolean): List<ULong>

@ExperimentalUnsignedTypes

inline fun UShortArray.filter(predicate: (UShort) -> Boolean): List<UShort>

inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>

inline fun <K, V> Map<out K, V>.filter(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V>

filterIndexed

inline fun <T> Array<out T>.filterIndexed(predicate: (index: Int, T) -> Boolean): List<T>

inline fun BooleanArray.filterIndexed(predicate: (index: Int, Boolean) -> Boolean): List<Boolean>

inline fun ByteArray.filterIndexed(predicate: (index: Int, Byte) -> Boolean): List<Byte>

inline fun CharArray.filterIndexed(predicate: (index: Int, Char) -> Boolean): List<Char>

inline fun DoubleArray.filterIndexed(predicate: (index: Int, Double) -> Boolean): List<Double>

inline fun FloatArray.filterIndexed(predicate: (index: Int, Float) -> Boolean): List<Float>

inline fun IntArray.filterIndexed(predicate: (index: Int, Int) -> Boolean): List<Int>

inline fun LongArray.filterIndexed(predicate: (index: Int, Long) -> Boolean): List<Long>

inline fun ShortArray.filterIndexed(predicate: (index: Int, Short) -> Boolean): List<Short>

@ExperimentalUnsignedTypes

inline fun UByteArray.filterIndexed(predicate: (index: Int, UByte) -> Boolean): List<UByte>

@ExperimentalUnsignedTypes

inline fun UIntArray.filterIndexed(predicate: (index: Int, UInt) -> Boolean): List<UInt>

@ExperimentalUnsignedTypes

inline fun ULongArray.filterIndexed(predicate: (index: Int, ULong) -> Boolean): List<ULong>

@ExperimentalUnsignedTypes

inline fun UShortArray.filterIndexed(predicate: (index: Int, UShort) -> Boolean): List<UShort>

inline fun <T> Iterable<T>.filterIndexed(predicate: (index: Int, T) -> Boolean): List<T>

filterIndexedTo

inline fun <T, C : MutableCollection<in T>> Array<out T>.filterIndexedTo(destination: C, predicate: (index: Int, T) -> Boolean): C

inline fun <C : MutableCollection<in Boolean>> BooleanArray.filterIndexedTo(destination: C, predicate: (index: Int, Boolean) -> Boolean): C

inline fun <C : MutableCollection<in Byte>> ByteArray.filterIndexedTo(destination: C, predicate: (index: Int, Byte) -> Boolean): C

inline fun <C : MutableCollection<in Char>> CharArray.filterIndexedTo(destination: C, predicate: (index: Int, Char) -> Boolean): C

inline fun <C : MutableCollection<in Double>> DoubleArray.filterIndexedTo(destination: C, predicate: (index: Int, Double) -> Boolean): C

inline fun <C : MutableCollection<in Float>> FloatArray.filterIndexedTo(destination: C, predicate: (index: Int, Float) -> Boolean): C

inline fun <C : MutableCollection<in Int>> IntArray.filterIndexedTo(destination: C, predicate: (index: Int, Int) -> Boolean): C

inline fun <C : MutableCollection<in Long>> LongArray.filterIndexedTo(destination: C, predicate: (index: Int, Long) -> Boolean): C

inline fun <C : MutableCollection<in Short>> ShortArray.filterIndexedTo(destination: C, predicate: (index: Int, Short) -> Boolean): C

@ExperimentalUnsignedTypes

inline fun <C : MutableCollection<in UByte>> UByteArray.filterIndexedTo(destination: C, predicate: (index: Int, UByte) -> Boolean): C

@ExperimentalUnsignedTypes

inline fun <C : MutableCollection<in UInt>> UIntArray.filterIndexedTo(destination: C, predicate: (index: Int, UInt) -> Boolean): C

@ExperimentalUnsignedTypes

inline fun <C : MutableCollection<in ULong>> ULongArray.filterIndexedTo(destination: C, predicate: (index: Int, ULong) -> Boolean): C

@ExperimentalUnsignedTypes

inline fun <C : MutableCollection<in UShort>> UShortArray.filterIndexedTo(destination: C, predicate: (index: Int, UShort) -> Boolean): C

inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterIndexedTo(destination: C, predicate: (index: Int, T) -> Boolean): C

filterIsInstance

inline fun <R> Array<*>.filterIsInstance(): List<R>

inline fun <R> Iterable<*>.filterIsInstance(): List<R>

filterIsInstanceTo

inline fun <R, C : MutableCollection<in R>> Array<*>.filterIsInstanceTo(destination: C): C

inline fun <R, C : MutableCollection<in R>> Iterable<*>.filterIsInstanceTo(destination: C): C

filterKeys

inline fun <K, V> Map<out K, V>.filterKeys(predicate: (K) -> Boolean): Map<K, V>

filterNot

inline fun <T> Array<out T>.filterNot(predicate: (T) -> Boolean): List<T>

inline fun BooleanArray.filterNot(predicate: (Boolean) -> Boolean): List<Boolean>

inline fun ByteArray.filterNot(predicate: (Byte) -> Boolean): List<Byte>

inline fun CharArray.filterNot(predicate: (Char) -> Boolean): List<Char>

inline fun DoubleArray.filterNot(predicate: (Double) -> Boolean): List<Double>

inline fun FloatArray.filterNot(predicate: (Float) -> Boolean): List<Float>

inline fun IntArray.filterNot(predicate: (Int) -> Boolean): List<Int>

inline fun LongArray.filterNot(predicate: (Long) -> Boolean): List<Long>

inline fun ShortArray.filterNot(predicate: (Short) -> Boolean): List<Short>

@ExperimentalUnsignedTypes

inline fun UByteArray.filterNot(predicate: (UByte) -> Boolean): List<UByte>

@ExperimentalUnsignedTypes

inline fun UIntArray.filterNot(predicate: (UInt) -> Boolean): List<UInt>

@ExperimentalUnsignedTypes

inline fun ULongArray.filterNot(predicate: (ULong) -> Boolean): List<ULong>

@ExperimentalUnsignedTypes

inline fun UShortArray.filterNot(predicate: (UShort) -> Boolean): List<UShort>

inline fun <T> Iterable<T>.filterNot(predicate: (T) -> Boolean): List<T>

inline fun <K, V> Map<out K, V>.filterNot(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V>

filterNotNull

fun <T : Any> Array<out T?>.filterNotNull(): List<T>

fun <T : Any> Iterable<T?>.filterNotNull(): List<T>

filterNotNullTo

fun <C : MutableCollection<in T>, T : Any> Array<out T?>.filterNotNullTo(destination: C): C

fun <C : MutableCollection<in T>, T : Any> Iterable<T?>.filterNotNullTo(destination: C): C

filterNotTo

inline fun <T, C : MutableCollection<in T>> Array<out T>.filterNotTo(destination: C, predicate: (T) -> Boolean): C

inline fun <C : MutableCollection<in Boolean>> BooleanArray.filterNotTo(destination: C, predicate: (Boolean) -> Boolean): C

inline fun <C : MutableCollection<in Byte>> ByteArray.filterNotTo(destination: C, predicate: (Byte) -> Boolean): C

inline fun <C : MutableCollection<in Char>> CharArray.filterNotTo(destination: C, predicate: (Char) -> Boolean): C

inline fun <C : MutableCollection<in Double>> DoubleArray.filterNotTo(destination: C, predicate: (Double) -> Boolean): C

inline fun <C : MutableCollection<in Float>> FloatArray.filterNotTo(destination: C, predicate: (Float) -> Boolean): C

inline fun <C : MutableCollection<in Int>> IntArray.filterNotTo(destination: C, predicate: (Int) -> Boolean): C

inline fun <C : MutableCollection<in Long>> LongArray.filterNotTo(destination: C, predicate: (Long) -> Boolean): C

inline fun <C : MutableCollection<in Short>> ShortArray.filterNotTo(destination: C, predicate: (Short) -> Boolean): C

@ExperimentalUnsignedTypes

inline fun <C : MutableCollection<in UByte>> UByteArray.filterNotTo(destination: C, predicate: (UByte) -> Boolean): C

@ExperimentalUnsignedTypes

inline fun <C : MutableCollection<in UInt>> UIntArray.filterNotTo(destination: C, predicate: (UInt) -> Boolean): C

@ExperimentalUnsignedTypes

inline fun <C : MutableCollection<in ULong>> ULongArray.filterNotTo(destination: C, predicate: (ULong) -> Boolean): C

@ExperimentalUnsignedTypes

inline fun <C : MutableCollection<in UShort>> UShortArray.filterNotTo(destination: C, predicate: (UShort) -> Boolean): C

inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterNotTo(destination: C, predicate: (T) -> Boolean): C

inline fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterNotTo(destination: M, predicate: (Map.Entry<K, V>) -> Boolean): M

filterTo

inline fun <T, C : MutableCollection<in T>> Array<out T>.filterTo(destination: C, predicate: (T) -> Boolean): C

inline fun <C : MutableCollection<in Boolean>> BooleanArray.filterTo(destination: C, predicate: (Boolean) -> Boolean): C

inline fun <C : MutableCollection<in Byte>> ByteArray.filterTo(destination: C, predicate: (Byte) -> Boolean): C

inline fun <C : MutableCollection<in Char>> CharArray.filterTo(destination: C, predicate: (Char) -> Boolean): C

inline fun <C : MutableCollection<in Double>> DoubleArray.filterTo(destination: C, predicate: (Double) -> Boolean): C

inline fun <C : MutableCollection<in Float>> FloatArray.filterTo(destination: C, predicate: (Float) -> Boolean): C

inline fun <C : MutableCollection<in Int>> IntArray.filterTo(destination: C, predicate: (Int) -> Boolean): C

inline fun <C : MutableCollection<in Long>> LongArray.filterTo(destination: C, predicate: (Long) -> Boolean): C

inline fun <C : MutableCollection<in Short>> ShortArray.filterTo(destination: C, predicate: (Short) -> Boolean): C

@ExperimentalUnsignedTypes

inline fun <C : MutableCollection<in UByte>> UByteArray.filterTo(destination: C, predicate: (UByte) -> Boolean): C

@ExperimentalUnsignedTypes

inline fun <C : MutableCollection<in UInt>> UIntArray.filterTo(destination: C, predicate: (UInt) -> Boolean): C

@ExperimentalUnsignedTypes

inline fun <C : MutableCollection<in ULong>> ULongArray.filterTo(destination: C, predicate: (ULong) -> Boolean): C

@ExperimentalUnsignedTypes

inline fun <C : MutableCollection<in UShort>> UShortArray.filterTo(destination: C, predicate: (UShort) -> Boolean): C

inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(destination: C, predicate: (T) -> Boolean): C

inline fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterTo(destination: M, predicate: (Map.Entry<K, V>) -> Boolean): M

filterValues

inline fun <K, V> Map<out K, V>.filterValues(predicate: (V) -> Boolean): Map<K, V>

find

inline fun <T> Array<out T>.find(predicate: (T) -> Boolean): T?

inline fun BooleanArray.find(predicate: (Boolean) -> Boolean): Boolean?

inline fun ByteArray.find(predicate: (Byte) -> Boolean): Byte?

inline fun CharArray.find(predicate: (Char) -> Boolean): Char?

inline fun DoubleArray.find(predicate: (Double) -> Boolean): Double?

inline fun FloatArray.find(predicate: (Float) -> Boolean): Float?

inline fun IntArray.find(predicate: (Int) -> Boolean): Int?

inline fun LongArray.find(predicate: (Long) -> Boolean): Long?

inline fun ShortArray.find(predicate: (Short) -> Boolean): Short?

@ExperimentalUnsignedTypes

inline fun UByteArray.find(predicate: (UByte) -> Boolean): UByte?

@ExperimentalUnsignedTypes

inline fun UIntArray.find(predicate: (UInt) -> Boolean): UInt?

@ExperimentalUnsignedTypes

inline fun ULongArray.find(predicate: (ULong) -> Boolean): ULong?

@ExperimentalUnsignedTypes

inline fun UShortArray.find(predicate: (UShort) -> Boolean): UShort?

inline fun <T> Iterable<T>.find(predicate: (T) -> Boolean): T?

findLast

inline fun <T> Array<out T>.findLast(predicate: (T) -> Boolean): T?

inline fun BooleanArray.findLast(predicate: (Boolean) -> Boolean): Boolean?

inline fun ByteArray.findLast(predicate: (Byte) -> Boolean): Byte?

inline fun CharArray.findLast(predicate: (Char) -> Boolean): Char?

inline fun DoubleArray.findLast(predicate: (Double) -> Boolean): Double?

inline fun FloatArray.findLast(predicate: (Float) -> Boolean): Float?

inline fun IntArray.findLast(predicate: (Int) -> Boolean): Int?

inline fun LongArray.findLast(predicate: (Long) -> Boolean): Long?

inline fun ShortArray.findLast(predicate: (Short) -> Boolean): Short?

@ExperimentalUnsignedTypes

inline fun UByteArray.findLast(predicate: (UByte) -> Boolean): UByte?

@ExperimentalUnsignedTypes

inline fun UIntArray.findLast(predicate: (UInt) -> Boolean): UInt?

@ExperimentalUnsignedTypes

inline fun ULongArray.findLast(predicate: (ULong) -> Boolean): ULong?

@ExperimentalUnsignedTypes

inline fun UShortArray.findLast(predicate: (UShort) -> Boolean): UShort?

inline fun <T> Iterable<T>.findLast(predicate: (T) -> Boolean): T?

inline fun <T> List<T>.findLast(predicate: (T) -> Boolean): T?

first

fun <T> Array<out T>.first(): T

fun BooleanArray.first(): Boolean

fun ByteArray.first(): Byte

fun CharArray.first(): Char

fun DoubleArray.first(): Double

fun FloatArray.first(): Float

fun IntArray.first(): Int

fun LongArray.first(): Long

fun ShortArray.first(): Short

@ExperimentalUnsignedTypes

inline fun UByteArray.first(): UByte

@ExperimentalUnsignedTypes

inline fun UIntArray.first(): UInt

@ExperimentalUnsignedTypes

inline fun ULongArray.first(): ULong

@ExperimentalUnsignedTypes

inline fun UShortArray.first(): UShort

fun <T> Iterable<T>.first(): T

fun <T> List<T>.first(): T

inline fun <T> Array<out T>.first(predicate: (T) -> Boolean): T

inline fun BooleanArray.first(predicate: (Boolean) -> Boolean): Boolean

inline fun ByteArray.first(predicate: (Byte) -> Boolean): Byte

inline fun CharArray.first(predicate: (Char) -> Boolean): Char

inline fun DoubleArray.first(predicate: (Double) -> Boolean): Double

inline fun FloatArray.first(predicate: (Float) -> Boolean): Float

inline fun IntArray.first(predicate: (Int) -> Boolean): Int

inline fun LongArray.first(predicate: (Long) -> Boolean): Long

inline fun ShortArray.first(predicate: (Short) -> Boolean): Short

@ExperimentalUnsignedTypes

inline fun UByteArray.first(predicate: (UByte) -> Boolean): UByte

@ExperimentalUnsignedTypes

inline fun UIntArray.first(predicate: (UInt) -> Boolean): UInt

@ExperimentalUnsignedTypes

inline fun ULongArray.first(predicate: (ULong) -> Boolean): ULong

@ExperimentalUnsignedTypes

inline fun UShortArray.first(predicate: (UShort) -> Boolean): UShort

inline fun <T> Iterable<T>.first(predicate: (T) -> Boolean): T

firstNotNullOf

inline fun <T, R : Any> Array<out T>.firstNotNullOf(transform: (T) -> R?): R

inline fun <T, R : Any> Iterable<T>.firstNotNullOf(transform: (T) -> R?): R

inline fun <K, V, R : Any> Map<out K, V>.firstNotNullOf(transform: (Map.Entry<K, V>) -> R?): R

firstNotNullOfOrNull

inline fun <T, R : Any> Array<out T>.firstNotNullOfOrNull(transform: (T) -> R?): R?

inline fun <T, R : Any> Iterable<T>.firstNotNullOfOrNull(transform: (T) -> R?): R?

inline fun <K, V, R : Any> Map<out K, V>.firstNotNullOfOrNull(transform: (Map.Entry<K, V>) -> R?): R?

firstOrNull

fun <T> Array<out T>.firstOrNull(): T?

fun BooleanArray.firstOrNull(): Boolean?

fun ByteArray.firstOrNull(): Byte?

fun CharArray.firstOrNull(): Char?

fun DoubleArray.firstOrNull(): Double?

fun FloatArray.firstOrNull(): Float?

fun IntArray.firstOrNull(): Int?

fun LongArray.firstOrNull(): Long?

fun ShortArray.firstOrNull(): Short?

@ExperimentalUnsignedTypes

fun UByteArray.firstOrNull(): UByte?

@ExperimentalUnsignedTypes

fun UIntArray.firstOrNull(): UInt?

@ExperimentalUnsignedTypes

fun ULongArray.firstOrNull(): ULong?

@ExperimentalUnsignedTypes

fun UShortArray.firstOrNull(): UShort?

fun <T> Iterable<T>.firstOrNull(): T?

fun <T> List<T>.firstOrNull(): T?

inline fun <T> Array<out T>.firstOrNull(predicate: (T) -> Boolean): T?

inline fun BooleanArray.firstOrNull(predicate: (Boolean) -> Boolean): Boolean?

inline fun ByteArray.firstOrNull(predicate: (Byte) -> Boolean): Byte?

inline fun CharArray.firstOrNull(predicate: (Char) -> Boolean): Char?

inline fun DoubleArray.firstOrNull(predicate: (Double) -> Boolean): Double?

inline fun FloatArray.firstOrNull(predicate: (Float) -> Boolean): Float?

inline fun IntArray.firstOrNull(predicate: (Int) -> Boolean): Int?

inline fun LongArray.firstOrNull(predicate: (Long) -> Boolean): Long?

inline fun ShortArray.firstOrNull(predicate: (Short) -> Boolean): Short?

@ExperimentalUnsignedTypes

inline fun UByteArray.firstOrNull(predicate: (UByte) -> Boolean): UByte?

@ExperimentalUnsignedTypes

inline fun UIntArray.firstOrNull(predicate: (UInt) -> Boolean): UInt?

@ExperimentalUnsignedTypes

inline fun ULongArray.firstOrNull(predicate: (ULong) -> Boolean): ULong?

@ExperimentalUnsignedTypes

inline fun UShortArray.firstOrNull(predicate: (UShort) -> Boolean): UShort?

inline fun <T> Iterable<T>.firstOrNull(predicate: (T) -> Boolean): T?

flatMap

inline fun <T, R> Array<out T>.flatMap(transform: (T) -> Iterable<R>): List<R>

@JvmName(name = "flatMapSequence")

inline fun <T, R> Array<out T>.flatMap(transform: (T) -> Sequence<R>): List<R>

inline fun <R> BooleanArray.flatMap(transform: (Boolean) -> Iterable<R>): List<R>

inline fun <R> ByteArray.flatMap(transform: (Byte) -> Iterable<R>): List<R>

inline fun <R> CharArray.flatMap(transform: (Char) -> Iterable<R>): List<R>

inline fun <R> DoubleArray.flatMap(transform: (Double) -> Iterable<R>): List<R>

inline fun <R> FloatArray.flatMap(transform: (Float) -> Iterable<R>): List<R>

inline fun <R> IntArray.flatMap(transform: (Int) -> Iterable<R>): List<R>

inline fun <R> LongArray.flatMap(transform: (Long) -> Iterable<R>): List<R>

inline fun <R> ShortArray.flatMap(transform: (Short) -> Iterable<R>): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UByteArray.flatMap(transform: (UByte) -> Iterable<R>): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UIntArray.flatMap(transform: (UInt) -> Iterable<R>): List<R>

@ExperimentalUnsignedTypes

inline fun <R> ULongArray.flatMap(transform: (ULong) -> Iterable<R>): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UShortArray.flatMap(transform: (UShort) -> Iterable<R>): List<R>

inline fun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R>

@JvmName(name = "flatMapSequence")

inline fun <T, R> Iterable<T>.flatMap(transform: (T) -> Sequence<R>): List<R>

inline fun <K, V, R> Map<out K, V>.flatMap(transform: (Map.Entry<K, V>) -> Iterable<R>): List<R>

@JvmName(name = "flatMapSequence")

inline fun <K, V, R> Map<out K, V>.flatMap(transform: (Map.Entry<K, V>) -> Sequence<R>): List<R>

flatMapIndexed

@JvmName(name = "flatMapIndexedIterable")

inline fun <T, R> Array<out T>.flatMapIndexed(transform: (index: Int, T) -> Iterable<R>): List<R>

@JvmName(name = "flatMapIndexedSequence")

inline fun <T, R> Array<out T>.flatMapIndexed(transform: (index: Int, T) -> Sequence<R>): List<R>

@JvmName(name = "flatMapIndexedIterable")

inline fun <R> BooleanArray.flatMapIndexed(transform: (index: Int, Boolean) -> Iterable<R>): List<R>

@JvmName(name = "flatMapIndexedIterable")

inline fun <R> ByteArray.flatMapIndexed(transform: (index: Int, Byte) -> Iterable<R>): List<R>

@JvmName(name = "flatMapIndexedIterable")

inline fun <R> CharArray.flatMapIndexed(transform: (index: Int, Char) -> Iterable<R>): List<R>

@JvmName(name = "flatMapIndexedIterable")

inline fun <R> DoubleArray.flatMapIndexed(transform: (index: Int, Double) -> Iterable<R>): List<R>

@JvmName(name = "flatMapIndexedIterable")

inline fun <R> FloatArray.flatMapIndexed(transform: (index: Int, Float) -> Iterable<R>): List<R>

@JvmName(name = "flatMapIndexedIterable")

inline fun <R> IntArray.flatMapIndexed(transform: (index: Int, Int) -> Iterable<R>): List<R>

@JvmName(name = "flatMapIndexedIterable")

inline fun <R> LongArray.flatMapIndexed(transform: (index: Int, Long) -> Iterable<R>): List<R>

@JvmName(name = "flatMapIndexedIterable")

inline fun <R> ShortArray.flatMapIndexed(transform: (index: Int, Short) -> Iterable<R>): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UByteArray.flatMapIndexed(transform: (index: Int, UByte) -> Iterable<R>): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UIntArray.flatMapIndexed(transform: (index: Int, UInt) -> Iterable<R>): List<R>

@ExperimentalUnsignedTypes

inline fun <R> ULongArray.flatMapIndexed(transform: (index: Int, ULong) -> Iterable<R>): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UShortArray.flatMapIndexed(transform: (index: Int, UShort) -> Iterable<R>): List<R>

@JvmName(name = "flatMapIndexedIterable")

inline fun <T, R> Iterable<T>.flatMapIndexed(transform: (index: Int, T) -> Iterable<R>): List<R>

@JvmName(name = "flatMapIndexedSequence")

inline fun <T, R> Iterable<T>.flatMapIndexed(transform: (index: Int, T) -> Sequence<R>): List<R>

flatMapIndexedTo

@JvmName(name = "flatMapIndexedIterableTo")

inline fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapIndexedTo(destination: C, transform: (index: Int, T) -> Iterable<R>): C

@JvmName(name = "flatMapIndexedSequenceTo")

inline fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapIndexedTo(destination: C, transform: (index: Int, T) -> Sequence<R>): C

@JvmName(name = "flatMapIndexedIterableTo")

inline fun <R, C : MutableCollection<in R>> BooleanArray.flatMapIndexedTo(destination: C, transform: (index: Int, Boolean) -> Iterable<R>): C

@JvmName(name = "flatMapIndexedIterableTo")

inline fun <R, C : MutableCollection<in R>> ByteArray.flatMapIndexedTo(destination: C, transform: (index: Int, Byte) -> Iterable<R>): C

@JvmName(name = "flatMapIndexedIterableTo")

inline fun <R, C : MutableCollection<in R>> CharArray.flatMapIndexedTo(destination: C, transform: (index: Int, Char) -> Iterable<R>): C

@JvmName(name = "flatMapIndexedIterableTo")

inline fun <R, C : MutableCollection<in R>> DoubleArray.flatMapIndexedTo(destination: C, transform: (index: Int, Double) -> Iterable<R>): C

@JvmName(name = "flatMapIndexedIterableTo")

inline fun <R, C : MutableCollection<in R>> FloatArray.flatMapIndexedTo(destination: C, transform: (index: Int, Float) -> Iterable<R>): C

@JvmName(name = "flatMapIndexedIterableTo")

inline fun <R, C : MutableCollection<in R>> IntArray.flatMapIndexedTo(destination: C, transform: (index: Int, Int) -> Iterable<R>): C

@JvmName(name = "flatMapIndexedIterableTo")

inline fun <R, C : MutableCollection<in R>> LongArray.flatMapIndexedTo(destination: C, transform: (index: Int, Long) -> Iterable<R>): C

@JvmName(name = "flatMapIndexedIterableTo")

inline fun <R, C : MutableCollection<in R>> ShortArray.flatMapIndexedTo(destination: C, transform: (index: Int, Short) -> Iterable<R>): C

@ExperimentalUnsignedTypes

inline fun <R, C : MutableCollection<in R>> UByteArray.flatMapIndexedTo(destination: C, transform: (index: Int, UByte) -> Iterable<R>): C

@ExperimentalUnsignedTypes

inline fun <R, C : MutableCollection<in R>> UIntArray.flatMapIndexedTo(destination: C, transform: (index: Int, UInt) -> Iterable<R>): C

@ExperimentalUnsignedTypes

inline fun <R, C : MutableCollection<in R>> ULongArray.flatMapIndexedTo(destination: C, transform: (index: Int, ULong) -> Iterable<R>): C

@ExperimentalUnsignedTypes

inline fun <R, C : MutableCollection<in R>> UShortArray.flatMapIndexedTo(destination: C, transform: (index: Int, UShort) -> Iterable<R>): C

@JvmName(name = "flatMapIndexedIterableTo")

inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapIndexedTo(destination: C, transform: (index: Int, T) -> Iterable<R>): C

@JvmName(name = "flatMapIndexedSequenceTo")

inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapIndexedTo(destination: C, transform: (index: Int, T) -> Sequence<R>): C

flatMapTo

inline fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapTo(destination: C, transform: (T) -> Iterable<R>): C

@JvmName(name = "flatMapSequenceTo")

inline fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapTo(destination: C, transform: (T) -> Sequence<R>): C

inline fun <R, C : MutableCollection<in R>> BooleanArray.flatMapTo(destination: C, transform: (Boolean) -> Iterable<R>): C

inline fun <R, C : MutableCollection<in R>> ByteArray.flatMapTo(destination: C, transform: (Byte) -> Iterable<R>): C

inline fun <R, C : MutableCollection<in R>> CharArray.flatMapTo(destination: C, transform: (Char) -> Iterable<R>): C

inline fun <R, C : MutableCollection<in R>> DoubleArray.flatMapTo(destination: C, transform: (Double) -> Iterable<R>): C

inline fun <R, C : MutableCollection<in R>> FloatArray.flatMapTo(destination: C, transform: (Float) -> Iterable<R>): C

inline fun <R, C : MutableCollection<in R>> IntArray.flatMapTo(destination: C, transform: (Int) -> Iterable<R>): C

inline fun <R, C : MutableCollection<in R>> LongArray.flatMapTo(destination: C, transform: (Long) -> Iterable<R>): C

inline fun <R, C : MutableCollection<in R>> ShortArray.flatMapTo(destination: C, transform: (Short) -> Iterable<R>): C

@ExperimentalUnsignedTypes

inline fun <R, C : MutableCollection<in R>> UByteArray.flatMapTo(destination: C, transform: (UByte) -> Iterable<R>): C

@ExperimentalUnsignedTypes

inline fun <R, C : MutableCollection<in R>> UIntArray.flatMapTo(destination: C, transform: (UInt) -> Iterable<R>): C

@ExperimentalUnsignedTypes

inline fun <R, C : MutableCollection<in R>> ULongArray.flatMapTo(destination: C, transform: (ULong) -> Iterable<R>): C

@ExperimentalUnsignedTypes

inline fun <R, C : MutableCollection<in R>> UShortArray.flatMapTo(destination: C, transform: (UShort) -> Iterable<R>): C

inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(destination: C, transform: (T) -> Iterable<R>): C

@JvmName(name = "flatMapSequenceTo")

inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(destination: C, transform: (T) -> Sequence<R>): C

inline fun <K, V, R, C : MutableCollection<in R>> Map<out K, V>.flatMapTo(destination: C, transform: (Map.Entry<K, V>) -> Iterable<R>): C

@JvmName(name = "flatMapSequenceTo")

inline fun <K, V, R, C : MutableCollection<in R>> Map<out K, V>.flatMapTo(destination: C, transform: (Map.Entry<K, V>) -> Sequence<R>): C

flatten

fun <T> Array<out Array<out T>>.flatten(): List<T>

fun <T> Iterable<Iterable<T>>.flatten(): List<T>

fold

inline fun <T, R> Array<out T>.fold(initial: R, operation: (acc: R, T) -> R): R

inline fun <R> BooleanArray.fold(initial: R, operation: (acc: R, Boolean) -> R): R

inline fun <R> ByteArray.fold(initial: R, operation: (acc: R, Byte) -> R): R

inline fun <R> CharArray.fold(initial: R, operation: (acc: R, Char) -> R): R

inline fun <R> DoubleArray.fold(initial: R, operation: (acc: R, Double) -> R): R

inline fun <R> FloatArray.fold(initial: R, operation: (acc: R, Float) -> R): R

inline fun <R> IntArray.fold(initial: R, operation: (acc: R, Int) -> R): R

inline fun <R> LongArray.fold(initial: R, operation: (acc: R, Long) -> R): R

inline fun <R> ShortArray.fold(initial: R, operation: (acc: R, Short) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> UByteArray.fold(initial: R, operation: (acc: R, UByte) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> UIntArray.fold(initial: R, operation: (acc: R, UInt) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> ULongArray.fold(initial: R, operation: (acc: R, ULong) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> UShortArray.fold(initial: R, operation: (acc: R, UShort) -> R): R

inline fun <T, K, R> Grouping<T, K>.fold(initialValue: R, operation: (accumulator: R, element: T) -> R): Map<K, R>

inline fun <T, K, R> Grouping<T, K>.fold(initialValueSelector: (key: K, element: T) -> R, operation: (key: K, accumulator: R, element: T) -> R): Map<K, R>

inline fun <T, R> Iterable<T>.fold(initial: R, operation: (acc: R, T) -> R): R

foldIndexed

inline fun <T, R> Array<out T>.foldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): R

inline fun <R> BooleanArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Boolean) -> R): R

inline fun <R> ByteArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Byte) -> R): R

inline fun <R> CharArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Char) -> R): R

inline fun <R> DoubleArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Double) -> R): R

inline fun <R> FloatArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Float) -> R): R

inline fun <R> IntArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Int) -> R): R

inline fun <R> LongArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Long) -> R): R

inline fun <R> ShortArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Short) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> UByteArray.foldIndexed(initial: R, operation: (index: Int, acc: R, UByte) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> UIntArray.foldIndexed(initial: R, operation: (index: Int, acc: R, UInt) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> ULongArray.foldIndexed(initial: R, operation: (index: Int, acc: R, ULong) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> UShortArray.foldIndexed(initial: R, operation: (index: Int, acc: R, UShort) -> R): R

inline fun <T, R> Iterable<T>.foldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): R

foldRight

inline fun <T, R> Array<out T>.foldRight(initial: R, operation: (T, acc: R) -> R): R

inline fun <R> BooleanArray.foldRight(initial: R, operation: (Boolean, acc: R) -> R): R

inline fun <R> ByteArray.foldRight(initial: R, operation: (Byte, acc: R) -> R): R

inline fun <R> CharArray.foldRight(initial: R, operation: (Char, acc: R) -> R): R

inline fun <R> DoubleArray.foldRight(initial: R, operation: (Double, acc: R) -> R): R

inline fun <R> FloatArray.foldRight(initial: R, operation: (Float, acc: R) -> R): R

inline fun <R> IntArray.foldRight(initial: R, operation: (Int, acc: R) -> R): R

inline fun <R> LongArray.foldRight(initial: R, operation: (Long, acc: R) -> R): R

inline fun <R> ShortArray.foldRight(initial: R, operation: (Short, acc: R) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> UByteArray.foldRight(initial: R, operation: (UByte, acc: R) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> UIntArray.foldRight(initial: R, operation: (UInt, acc: R) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> ULongArray.foldRight(initial: R, operation: (ULong, acc: R) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> UShortArray.foldRight(initial: R, operation: (UShort, acc: R) -> R): R

inline fun <T, R> List<T>.foldRight(initial: R, operation: (T, acc: R) -> R): R

foldRightIndexed

inline fun <T, R> Array<out T>.foldRightIndexed(initial: R, operation: (index: Int, T, acc: R) -> R): R

inline fun <R> BooleanArray.foldRightIndexed(initial: R, operation: (index: Int, Boolean, acc: R) -> R): R

inline fun <R> ByteArray.foldRightIndexed(initial: R, operation: (index: Int, Byte, acc: R) -> R): R

inline fun <R> CharArray.foldRightIndexed(initial: R, operation: (index: Int, Char, acc: R) -> R): R

inline fun <R> DoubleArray.foldRightIndexed(initial: R, operation: (index: Int, Double, acc: R) -> R): R

inline fun <R> FloatArray.foldRightIndexed(initial: R, operation: (index: Int, Float, acc: R) -> R): R

inline fun <R> IntArray.foldRightIndexed(initial: R, operation: (index: Int, Int, acc: R) -> R): R

inline fun <R> LongArray.foldRightIndexed(initial: R, operation: (index: Int, Long, acc: R) -> R): R

inline fun <R> ShortArray.foldRightIndexed(initial: R, operation: (index: Int, Short, acc: R) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> UByteArray.foldRightIndexed(initial: R, operation: (index: Int, UByte, acc: R) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> UIntArray.foldRightIndexed(initial: R, operation: (index: Int, UInt, acc: R) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> ULongArray.foldRightIndexed(initial: R, operation: (index: Int, ULong, acc: R) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> UShortArray.foldRightIndexed(initial: R, operation: (index: Int, UShort, acc: R) -> R): R

inline fun <T, R> List<T>.foldRightIndexed(initial: R, operation: (index: Int, T, acc: R) -> R): R

foldTo

inline fun <T, K, R, M : MutableMap<in K, R>> Grouping<T, K>.foldTo( destination: M, initialValue: R, operation: (accumulator: R, element: T) -> R): M

inline fun <T, K, R, M : MutableMap<in K, R>> Grouping<T, K>.foldTo( destination: M, initialValueSelector: (key: K, element: T) -> R, operation: (key: K, accumulator: R, element: T) -> R): M

forEach

inline fun <T> Array<out T>.forEach(action: (T) -> Unit)

inline fun BooleanArray.forEach(action: (Boolean) -> Unit)

inline fun ByteArray.forEach(action: (Byte) -> Unit)

inline fun CharArray.forEach(action: (Char) -> Unit)

inline fun DoubleArray.forEach(action: (Double) -> Unit)

inline fun FloatArray.forEach(action: (Float) -> Unit)

inline fun IntArray.forEach(action: (Int) -> Unit)

inline fun LongArray.forEach(action: (Long) -> Unit)

inline fun ShortArray.forEach(action: (Short) -> Unit)

@ExperimentalUnsignedTypes

inline fun UByteArray.forEach(action: (UByte) -> Unit)

@ExperimentalUnsignedTypes

inline fun UIntArray.forEach(action: (UInt) -> Unit)

@ExperimentalUnsignedTypes

inline fun ULongArray.forEach(action: (ULong) -> Unit)

@ExperimentalUnsignedTypes

inline fun UShortArray.forEach(action: (UShort) -> Unit)

inline fun <T> Iterable<T>.forEach(action: (T) -> Unit)

inline fun <T> Iterator<T>.forEach(operation: (T) -> Unit)

inline fun <K, V> Map<out K, V>.forEach(action: (Map.Entry<K, V>) -> Unit)

forEachIndexed

inline fun <T> Array<out T>.forEachIndexed(action: (index: Int, T) -> Unit)

inline fun BooleanArray.forEachIndexed(action: (index: Int, Boolean) -> Unit)

inline fun ByteArray.forEachIndexed(action: (index: Int, Byte) -> Unit)

inline fun CharArray.forEachIndexed(action: (index: Int, Char) -> Unit)

inline fun DoubleArray.forEachIndexed(action: (index: Int, Double) -> Unit)

inline fun FloatArray.forEachIndexed(action: (index: Int, Float) -> Unit)

inline fun IntArray.forEachIndexed(action: (index: Int, Int) -> Unit)

inline fun LongArray.forEachIndexed(action: (index: Int, Long) -> Unit)

inline fun ShortArray.forEachIndexed(action: (index: Int, Short) -> Unit)

@ExperimentalUnsignedTypes

inline fun UByteArray.forEachIndexed(action: (index: Int, UByte) -> Unit)

@ExperimentalUnsignedTypes

inline fun UIntArray.forEachIndexed(action: (index: Int, UInt) -> Unit)

@ExperimentalUnsignedTypes

inline fun ULongArray.forEachIndexed(action: (index: Int, ULong) -> Unit)

@ExperimentalUnsignedTypes

inline fun UShortArray.forEachIndexed(action: (index: Int, UShort) -> Unit)

inline fun <T> Iterable<T>.forEachIndexed(action: (index: Int, T) -> Unit)

get

inline operator fun <K, V> Map<out K, V>.get(key: K): V?

getOrElse

inline fun <T> Array<out T>.getOrElse(index: Int, defaultValue: (Int) -> T): T

inline fun BooleanArray.getOrElse(index: Int, defaultValue: (Int) -> Boolean): Boolean

inline fun ByteArray.getOrElse(index: Int, defaultValue: (Int) -> Byte): Byte

inline fun CharArray.getOrElse(index: Int, defaultValue: (Int) -> Char): Char

inline fun DoubleArray.getOrElse(index: Int, defaultValue: (Int) -> Double): Double

inline fun FloatArray.getOrElse(index: Int, defaultValue: (Int) -> Float): Float

inline fun IntArray.getOrElse(index: Int, defaultValue: (Int) -> Int): Int

inline fun LongArray.getOrElse(index: Int, defaultValue: (Int) -> Long): Long

inline fun ShortArray.getOrElse(index: Int, defaultValue: (Int) -> Short): Short

@ExperimentalUnsignedTypes

inline fun UByteArray.getOrElse(index: Int, defaultValue: (Int) -> UByte): UByte

@ExperimentalUnsignedTypes

inline fun UIntArray.getOrElse(index: Int, defaultValue: (Int) -> UInt): UInt

@ExperimentalUnsignedTypes

inline fun ULongArray.getOrElse(index: Int, defaultValue: (Int) -> ULong): ULong

@ExperimentalUnsignedTypes

inline fun UShortArray.getOrElse(index: Int, defaultValue: (Int) -> UShort): UShort

inline fun <T> List<T>.getOrElse(index: Int, defaultValue: (Int) -> T): T

inline fun <K, V> Map<K, V>.getOrElse(key: K, defaultValue: () -> V): V

getOrNull

fun <T> Array<out T>.getOrNull(index: Int): T?

fun BooleanArray.getOrNull(index: Int): Boolean?

fun ByteArray.getOrNull(index: Int): Byte?

fun CharArray.getOrNull(index: Int): Char?

fun DoubleArray.getOrNull(index: Int): Double?

fun FloatArray.getOrNull(index: Int): Float?

fun IntArray.getOrNull(index: Int): Int?

fun LongArray.getOrNull(index: Int): Long?

fun ShortArray.getOrNull(index: Int): Short?

@ExperimentalUnsignedTypes

fun UByteArray.getOrNull(index: Int): UByte?

@ExperimentalUnsignedTypes

fun UIntArray.getOrNull(index: Int): UInt?

@ExperimentalUnsignedTypes

fun ULongArray.getOrNull(index: Int): ULong?

@ExperimentalUnsignedTypes

fun UShortArray.getOrNull(index: Int): UShort?

fun <T> List<T>.getOrNull(index: Int): T?

getOrPut

inline fun <K, V> MutableMap<K, V>.getOrPut(key: K, defaultValue: () -> V): V

getValue

fun <K, V> Map<K, V>.getValue(key: K): V

inline operator fun <V, V1 : V> Map<in String, V>.getValue(thisRef: Any?, property: KProperty<*>): V1

@JvmName(name = "getVar")

inline operator fun <V, V1 : V> MutableMap<in String, out V>.getValue(thisRef: Any?, property: KProperty<*>): V1

groupBy

inline fun <T, K> Array<out T>.groupBy(keySelector: (T) -> K): Map<K, List<T>>

inline fun <K> BooleanArray.groupBy(keySelector: (Boolean) -> K): Map<K, List<Boolean>>

inline fun <K> ByteArray.groupBy(keySelector: (Byte) -> K): Map<K, List<Byte>>

inline fun <K> CharArray.groupBy(keySelector: (Char) -> K): Map<K, List<Char>>

inline fun <K> DoubleArray.groupBy(keySelector: (Double) -> K): Map<K, List<Double>>

inline fun <K> FloatArray.groupBy(keySelector: (Float) -> K): Map<K, List<Float>>

inline fun <K> IntArray.groupBy(keySelector: (Int) -> K): Map<K, List<Int>>

inline fun <K> LongArray.groupBy(keySelector: (Long) -> K): Map<K, List<Long>>

inline fun <K> ShortArray.groupBy(keySelector: (Short) -> K): Map<K, List<Short>>

@ExperimentalUnsignedTypes

inline fun <K> UByteArray.groupBy(keySelector: (UByte) -> K): Map<K, List<UByte>>

@ExperimentalUnsignedTypes

inline fun <K> UIntArray.groupBy(keySelector: (UInt) -> K): Map<K, List<UInt>>

@ExperimentalUnsignedTypes

inline fun <K> ULongArray.groupBy(keySelector: (ULong) -> K): Map<K, List<ULong>>

@ExperimentalUnsignedTypes

inline fun <K> UShortArray.groupBy(keySelector: (UShort) -> K): Map<K, List<UShort>>

inline fun <T, K> Iterable<T>.groupBy(keySelector: (T) -> K): Map<K, List<T>>

inline fun <T, K, V> Array<out T>.groupBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, List<V>>

inline fun <K, V> BooleanArray.groupBy(keySelector: (Boolean) -> K, valueTransform: (Boolean) -> V): Map<K, List<V>>

inline fun <K, V> ByteArray.groupBy(keySelector: (Byte) -> K, valueTransform: (Byte) -> V): Map<K, List<V>>

inline fun <K, V> CharArray.groupBy(keySelector: (Char) -> K, valueTransform: (Char) -> V): Map<K, List<V>>

inline fun <K, V> DoubleArray.groupBy(keySelector: (Double) -> K, valueTransform: (Double) -> V): Map<K, List<V>>

inline fun <K, V> FloatArray.groupBy(keySelector: (Float) -> K, valueTransform: (Float) -> V): Map<K, List<V>>

inline fun <K, V> IntArray.groupBy(keySelector: (Int) -> K, valueTransform: (Int) -> V): Map<K, List<V>>

inline fun <K, V> LongArray.groupBy(keySelector: (Long) -> K, valueTransform: (Long) -> V): Map<K, List<V>>

inline fun <K, V> ShortArray.groupBy(keySelector: (Short) -> K, valueTransform: (Short) -> V): Map<K, List<V>>

@ExperimentalUnsignedTypes

inline fun <K, V> UByteArray.groupBy(keySelector: (UByte) -> K, valueTransform: (UByte) -> V): Map<K, List<V>>

@ExperimentalUnsignedTypes

inline fun <K, V> UIntArray.groupBy(keySelector: (UInt) -> K, valueTransform: (UInt) -> V): Map<K, List<V>>

@ExperimentalUnsignedTypes

inline fun <K, V> ULongArray.groupBy(keySelector: (ULong) -> K, valueTransform: (ULong) -> V): Map<K, List<V>>

@ExperimentalUnsignedTypes

inline fun <K, V> UShortArray.groupBy(keySelector: (UShort) -> K, valueTransform: (UShort) -> V): Map<K, List<V>>

inline fun <T, K, V> Iterable<T>.groupBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, List<V>>

groupByTo

inline fun <T, K, M : MutableMap<in K, MutableList<T>>> Array<out T>.groupByTo(destination: M, keySelector: (T) -> K): M

inline fun <K, M : MutableMap<in K, MutableList<Boolean>>> BooleanArray.groupByTo(destination: M, keySelector: (Boolean) -> K): M

inline fun <K, M : MutableMap<in K, MutableList<Byte>>> ByteArray.groupByTo(destination: M, keySelector: (Byte) -> K): M

inline fun <K, M : MutableMap<in K, MutableList<Char>>> CharArray.groupByTo(destination: M, keySelector: (Char) -> K): M

inline fun <K, M : MutableMap<in K, MutableList<Double>>> DoubleArray.groupByTo(destination: M, keySelector: (Double) -> K): M

inline fun <K, M : MutableMap<in K, MutableList<Float>>> FloatArray.groupByTo(destination: M, keySelector: (Float) -> K): M

inline fun <K, M : MutableMap<in K, MutableList<Int>>> IntArray.groupByTo(destination: M, keySelector: (Int) -> K): M

inline fun <K, M : MutableMap<in K, MutableList<Long>>> LongArray.groupByTo(destination: M, keySelector: (Long) -> K): M

inline fun <K, M : MutableMap<in K, MutableList<Short>>> ShortArray.groupByTo(destination: M, keySelector: (Short) -> K): M

@ExperimentalUnsignedTypes

inline fun <K, M : MutableMap<in K, MutableList<UByte>>> UByteArray.groupByTo(destination: M, keySelector: (UByte) -> K): M

@ExperimentalUnsignedTypes

inline fun <K, M : MutableMap<in K, MutableList<UInt>>> UIntArray.groupByTo(destination: M, keySelector: (UInt) -> K): M

@ExperimentalUnsignedTypes

inline fun <K, M : MutableMap<in K, MutableList<ULong>>> ULongArray.groupByTo(destination: M, keySelector: (ULong) -> K): M

@ExperimentalUnsignedTypes

inline fun <K, M : MutableMap<in K, MutableList<UShort>>> UShortArray.groupByTo(destination: M, keySelector: (UShort) -> K): M

inline fun <T, K, M : MutableMap<in K, MutableList<T>>> Iterable<T>.groupByTo(destination: M, keySelector: (T) -> K): M

inline fun <T, K, V, M : MutableMap<in K, MutableList<V>>> Array<out T>.groupByTo( destination: M, keySelector: (T) -> K, valueTransform: (T) -> V): M

inline fun <K, V, M : MutableMap<in K, MutableList<V>>> BooleanArray.groupByTo( destination: M, keySelector: (Boolean) -> K, valueTransform: (Boolean) -> V): M

inline fun <K, V, M : MutableMap<in K, MutableList<V>>> ByteArray.groupByTo( destination: M, keySelector: (Byte) -> K, valueTransform: (Byte) -> V): M

inline fun <K, V, M : MutableMap<in K, MutableList<V>>> CharArray.groupByTo( destination: M, keySelector: (Char) -> K, valueTransform: (Char) -> V): M

inline fun <K, V, M : MutableMap<in K, MutableList<V>>> DoubleArray.groupByTo( destination: M, keySelector: (Double) -> K, valueTransform: (Double) -> V): M

inline fun <K, V, M : MutableMap<in K, MutableList<V>>> FloatArray.groupByTo( destination: M, keySelector: (Float) -> K, valueTransform: (Float) -> V): M

inline fun <K, V, M : MutableMap<in K, MutableList<V>>> IntArray.groupByTo( destination: M, keySelector: (Int) -> K, valueTransform: (Int) -> V): M

inline fun <K, V, M : MutableMap<in K, MutableList<V>>> LongArray.groupByTo( destination: M, keySelector: (Long) -> K, valueTransform: (Long) -> V): M

inline fun <K, V, M : MutableMap<in K, MutableList<V>>> ShortArray.groupByTo( destination: M, keySelector: (Short) -> K, valueTransform: (Short) -> V): M

@ExperimentalUnsignedTypes

inline fun <K, V, M : MutableMap<in K, MutableList<V>>> UByteArray.groupByTo( destination: M, keySelector: (UByte) -> K, valueTransform: (UByte) -> V): M

@ExperimentalUnsignedTypes

inline fun <K, V, M : MutableMap<in K, MutableList<V>>> UIntArray.groupByTo( destination: M, keySelector: (UInt) -> K, valueTransform: (UInt) -> V): M

@ExperimentalUnsignedTypes

inline fun <K, V, M : MutableMap<in K, MutableList<V>>> ULongArray.groupByTo( destination: M, keySelector: (ULong) -> K, valueTransform: (ULong) -> V): M

@ExperimentalUnsignedTypes

inline fun <K, V, M : MutableMap<in K, MutableList<V>>> UShortArray.groupByTo( destination: M, keySelector: (UShort) -> K, valueTransform: (UShort) -> V): M

inline fun <T, K, V, M : MutableMap<in K, MutableList<V>>> Iterable<T>.groupByTo( destination: M, keySelector: (T) -> K, valueTransform: (T) -> V): M

groupingBy

inline fun <T, K> Array<out T>.groupingBy(crossinline keySelector: (T) -> K): Grouping<T, K>

inline fun <T, K> Iterable<T>.groupingBy(crossinline keySelector: (T) -> K): Grouping<T, K>

hashMapOf

inline fun <K, V> hashMapOf(): HashMap<K, V>

fun <K, V> hashMapOf(vararg pairs: Pair<K, V>): HashMap<K, V>

hashSetOf

inline fun <T> hashSetOf(): HashSet<T>

fun <T> hashSetOf(vararg elements: T): HashSet<T>

ifEmpty

inline fun <C : Array<*>, R, R> C.ifEmpty(defaultValue: () -> R): R

inline fun <C : Collection<*>, R, R> C.ifEmpty(defaultValue: () -> R): R

inline fun <M : Map<*, *>, R, R> M.ifEmpty(defaultValue: () -> R): R

indexOf

fun <T> Array<out T>.indexOf(element: T): Int

fun BooleanArray.indexOf(element: Boolean): Int

fun ByteArray.indexOf(element: Byte): Int

fun CharArray.indexOf(element: Char): Int

@DeprecatedSinceKotlin(errorSince = "1.6", hiddenSince = "1.7", warningSince = "1.4")

~~fun~~ DoubleArray.~~indexOf~~(element: Double): Int

@DeprecatedSinceKotlin(errorSince = "1.6", hiddenSince = "1.7", warningSince = "1.4")

~~fun~~ FloatArray.~~indexOf~~(element: Float): Int

fun IntArray.indexOf(element: Int): Int

fun LongArray.indexOf(element: Long): Int

fun ShortArray.indexOf(element: Short): Int

@ExperimentalUnsignedTypes

inline fun UByteArray.indexOf(element: UByte): Int

@ExperimentalUnsignedTypes

inline fun UIntArray.indexOf(element: UInt): Int

@ExperimentalUnsignedTypes

inline fun ULongArray.indexOf(element: ULong): Int

@ExperimentalUnsignedTypes

inline fun UShortArray.indexOf(element: UShort): Int

fun <T> Iterable<T>.indexOf(element: T): Int

fun <T> List<T>.indexOf(element: T): Int

indexOfFirst

inline fun <T> Array<out T>.indexOfFirst(predicate: (T) -> Boolean): Int

inline fun BooleanArray.indexOfFirst(predicate: (Boolean) -> Boolean): Int

inline fun ByteArray.indexOfFirst(predicate: (Byte) -> Boolean): Int

inline fun CharArray.indexOfFirst(predicate: (Char) -> Boolean): Int

inline fun DoubleArray.indexOfFirst(predicate: (Double) -> Boolean): Int

inline fun FloatArray.indexOfFirst(predicate: (Float) -> Boolean): Int

inline fun IntArray.indexOfFirst(predicate: (Int) -> Boolean): Int

inline fun LongArray.indexOfFirst(predicate: (Long) -> Boolean): Int

inline fun ShortArray.indexOfFirst(predicate: (Short) -> Boolean): Int

@ExperimentalUnsignedTypes

inline fun UByteArray.indexOfFirst(predicate: (UByte) -> Boolean): Int

@ExperimentalUnsignedTypes

inline fun UIntArray.indexOfFirst(predicate: (UInt) -> Boolean): Int

@ExperimentalUnsignedTypes

inline fun ULongArray.indexOfFirst(predicate: (ULong) -> Boolean): Int

@ExperimentalUnsignedTypes

inline fun UShortArray.indexOfFirst(predicate: (UShort) -> Boolean): Int

inline fun <T> Iterable<T>.indexOfFirst(predicate: (T) -> Boolean): Int

inline fun <T> List<T>.indexOfFirst(predicate: (T) -> Boolean): Int

indexOfLast

inline fun <T> Array<out T>.indexOfLast(predicate: (T) -> Boolean): Int

inline fun BooleanArray.indexOfLast(predicate: (Boolean) -> Boolean): Int

inline fun ByteArray.indexOfLast(predicate: (Byte) -> Boolean): Int

inline fun CharArray.indexOfLast(predicate: (Char) -> Boolean): Int

inline fun DoubleArray.indexOfLast(predicate: (Double) -> Boolean): Int

inline fun FloatArray.indexOfLast(predicate: (Float) -> Boolean): Int

inline fun IntArray.indexOfLast(predicate: (Int) -> Boolean): Int

inline fun LongArray.indexOfLast(predicate: (Long) -> Boolean): Int

inline fun ShortArray.indexOfLast(predicate: (Short) -> Boolean): Int

@ExperimentalUnsignedTypes

inline fun UByteArray.indexOfLast(predicate: (UByte) -> Boolean): Int

@ExperimentalUnsignedTypes

inline fun UIntArray.indexOfLast(predicate: (UInt) -> Boolean): Int

@ExperimentalUnsignedTypes

inline fun ULongArray.indexOfLast(predicate: (ULong) -> Boolean): Int

@ExperimentalUnsignedTypes

inline fun UShortArray.indexOfLast(predicate: (UShort) -> Boolean): Int

inline fun <T> Iterable<T>.indexOfLast(predicate: (T) -> Boolean): Int

inline fun <T> List<T>.indexOfLast(predicate: (T) -> Boolean): Int

intersect

infix fun <T> Array<out T>.intersect(other: Iterable<T>): Set<T>

infix fun BooleanArray.intersect(other: Iterable<Boolean>): Set<Boolean>

infix fun ByteArray.intersect(other: Iterable<Byte>): Set<Byte>

infix fun CharArray.intersect(other: Iterable<Char>): Set<Char>

infix fun DoubleArray.intersect(other: Iterable<Double>): Set<Double>

infix fun FloatArray.intersect(other: Iterable<Float>): Set<Float>

infix fun IntArray.intersect(other: Iterable<Int>): Set<Int>

infix fun LongArray.intersect(other: Iterable<Long>): Set<Long>

infix fun ShortArray.intersect(other: Iterable<Short>): Set<Short>

infix fun <T> Iterable<T>.intersect(other: Iterable<T>): Set<T>

isEmpty

inline fun <T> Array<out T>.isEmpty(): Boolean

inline fun BooleanArray.isEmpty(): Boolean

inline fun ByteArray.isEmpty(): Boolean

inline fun CharArray.isEmpty(): Boolean

inline fun DoubleArray.isEmpty(): Boolean

inline fun FloatArray.isEmpty(): Boolean

inline fun IntArray.isEmpty(): Boolean

inline fun LongArray.isEmpty(): Boolean

inline fun ShortArray.isEmpty(): Boolean

isNotEmpty

inline fun <T> Array<out T>.isNotEmpty(): Boolean

inline fun BooleanArray.isNotEmpty(): Boolean

inline fun ByteArray.isNotEmpty(): Boolean

inline fun CharArray.isNotEmpty(): Boolean

inline fun DoubleArray.isNotEmpty(): Boolean

inline fun FloatArray.isNotEmpty(): Boolean

inline fun IntArray.isNotEmpty(): Boolean

inline fun LongArray.isNotEmpty(): Boolean

inline fun ShortArray.isNotEmpty(): Boolean

inline fun <T> Collection<T>.isNotEmpty(): Boolean

inline fun <K, V> Map<out K, V>.isNotEmpty(): Boolean

isNullOrEmpty

inline fun Array<*>?.isNullOrEmpty(): Boolean

inline fun <T> Collection<T>?.isNullOrEmpty(): Boolean

inline fun <K, V> Map<out K, V>?.isNullOrEmpty(): Boolean

Iterable

inline fun <T> Iterable(crossinline iterator: () -> Iterator<T>): Iterable<T>

iterator

inline operator fun <T> Iterator<T>.iterator(): Iterator<T>

inline operator fun <K, V> Map<out K, V>.iterator(): Iterator<Map.Entry<K, V>>

@JvmName(name = "mutableIterator")

inline operator fun <K, V> MutableMap<K, V>.iterator(): MutableIterator<MutableMap.MutableEntry<K, V>>

joinTo

fun <T, A : Appendable> Array<out T>.joinTo(buffer: A, separator: CharSequence)

fun <A : Appendable> BooleanArray.joinTo(buffer: A, separator: CharSequence)

fun <A : Appendable> ByteArray.joinTo(buffer: A, separator: CharSequence)

fun <A : Appendable> CharArray.joinTo(buffer: A, separator: CharSequence)

fun <A : Appendable> DoubleArray.joinTo(buffer: A, separator: CharSequence)

fun <A : Appendable> FloatArray.joinTo(buffer: A, separator: CharSequence)

fun <A : Appendable> IntArray.joinTo(buffer: A, separator: CharSequence)

fun <A : Appendable> LongArray.joinTo(buffer: A, separator: CharSequence)

fun <A : Appendable> ShortArray.joinTo(buffer: A, separator: CharSequence)

fun <T, A : Appendable> Iterable<T>.joinTo(buffer: A, separator: CharSequence)

joinToString

fun <T> Array<out T>.joinToString(separator: CharSequence)

fun BooleanArray.joinToString(separator: CharSequence)

fun ByteArray.joinToString(separator: CharSequence)

fun CharArray.joinToString(separator: CharSequence)

fun DoubleArray.joinToString(separator: CharSequence)

fun FloatArray.joinToString(separator: CharSequence)

fun IntArray.joinToString(separator: CharSequence)

fun LongArray.joinToString(separator: CharSequence)

fun ShortArray.joinToString(separator: CharSequence)

fun <T> Iterable<T>.joinToString(separator: CharSequence)

last

fun <T> Array<out T>.last(): T

fun BooleanArray.last(): Boolean

fun ByteArray.last(): Byte

fun CharArray.last(): Char

fun DoubleArray.last(): Double

fun FloatArray.last(): Float

fun IntArray.last(): Int

fun LongArray.last(): Long

fun ShortArray.last(): Short

@ExperimentalUnsignedTypes

inline fun UByteArray.last(): UByte

@ExperimentalUnsignedTypes

inline fun UIntArray.last(): UInt

@ExperimentalUnsignedTypes

inline fun ULongArray.last(): ULong

@ExperimentalUnsignedTypes

inline fun UShortArray.last(): UShort

fun <T> Iterable<T>.last(): T

fun <T> List<T>.last(): T

inline fun <T> Array<out T>.last(predicate: (T) -> Boolean): T

inline fun BooleanArray.last(predicate: (Boolean) -> Boolean): Boolean

inline fun ByteArray.last(predicate: (Byte) -> Boolean): Byte

inline fun CharArray.last(predicate: (Char) -> Boolean): Char

inline fun DoubleArray.last(predicate: (Double) -> Boolean): Double

inline fun FloatArray.last(predicate: (Float) -> Boolean): Float

inline fun IntArray.last(predicate: (Int) -> Boolean): Int

inline fun LongArray.last(predicate: (Long) -> Boolean): Long

inline fun ShortArray.last(predicate: (Short) -> Boolean): Short

@ExperimentalUnsignedTypes

inline fun UByteArray.last(predicate: (UByte) -> Boolean): UByte

@ExperimentalUnsignedTypes

inline fun UIntArray.last(predicate: (UInt) -> Boolean): UInt

@ExperimentalUnsignedTypes

inline fun ULongArray.last(predicate: (ULong) -> Boolean): ULong

@ExperimentalUnsignedTypes

inline fun UShortArray.last(predicate: (UShort) -> Boolean): UShort

inline fun <T> Iterable<T>.last(predicate: (T) -> Boolean): T

inline fun <T> List<T>.last(predicate: (T) -> Boolean): T

lastIndexOf

fun <T> Array<out T>.lastIndexOf(element: T): Int

fun BooleanArray.lastIndexOf(element: Boolean): Int

fun ByteArray.lastIndexOf(element: Byte): Int

fun CharArray.lastIndexOf(element: Char): Int

@DeprecatedSinceKotlin(errorSince = "1.6", hiddenSince = "1.7", warningSince = "1.4")

~~fun~~ DoubleArray.~~lastIndexOf~~(element: Double): Int

@DeprecatedSinceKotlin(errorSince = "1.6", hiddenSince = "1.7", warningSince = "1.4")

~~fun~~ FloatArray.~~lastIndexOf~~(element: Float): Int

fun IntArray.lastIndexOf(element: Int): Int

fun LongArray.lastIndexOf(element: Long): Int

fun ShortArray.lastIndexOf(element: Short): Int

@ExperimentalUnsignedTypes

inline fun UByteArray.lastIndexOf(element: UByte): Int

@ExperimentalUnsignedTypes

inline fun UIntArray.lastIndexOf(element: UInt): Int

@ExperimentalUnsignedTypes

inline fun ULongArray.lastIndexOf(element: ULong): Int

@ExperimentalUnsignedTypes

inline fun UShortArray.lastIndexOf(element: UShort): Int

fun <T> Iterable<T>.lastIndexOf(element: T): Int

fun <T> List<T>.lastIndexOf(element: T): Int

lastOrNull

fun <T> Array<out T>.lastOrNull(): T?

fun BooleanArray.lastOrNull(): Boolean?

fun ByteArray.lastOrNull(): Byte?

fun CharArray.lastOrNull(): Char?

fun DoubleArray.lastOrNull(): Double?

fun FloatArray.lastOrNull(): Float?

fun IntArray.lastOrNull(): Int?

fun LongArray.lastOrNull(): Long?

fun ShortArray.lastOrNull(): Short?

@ExperimentalUnsignedTypes

fun UByteArray.lastOrNull(): UByte?

@ExperimentalUnsignedTypes

fun UIntArray.lastOrNull(): UInt?

@ExperimentalUnsignedTypes

fun ULongArray.lastOrNull(): ULong?

@ExperimentalUnsignedTypes

fun UShortArray.lastOrNull(): UShort?

fun <T> Iterable<T>.lastOrNull(): T?

fun <T> List<T>.lastOrNull(): T?

inline fun <T> Array<out T>.lastOrNull(predicate: (T) -> Boolean): T?

inline fun BooleanArray.lastOrNull(predicate: (Boolean) -> Boolean): Boolean?

inline fun ByteArray.lastOrNull(predicate: (Byte) -> Boolean): Byte?

inline fun CharArray.lastOrNull(predicate: (Char) -> Boolean): Char?

inline fun DoubleArray.lastOrNull(predicate: (Double) -> Boolean): Double?

inline fun FloatArray.lastOrNull(predicate: (Float) -> Boolean): Float?

inline fun IntArray.lastOrNull(predicate: (Int) -> Boolean): Int?

inline fun LongArray.lastOrNull(predicate: (Long) -> Boolean): Long?

inline fun ShortArray.lastOrNull(predicate: (Short) -> Boolean): Short?

@ExperimentalUnsignedTypes

inline fun UByteArray.lastOrNull(predicate: (UByte) -> Boolean): UByte?

@ExperimentalUnsignedTypes

inline fun UIntArray.lastOrNull(predicate: (UInt) -> Boolean): UInt?

@ExperimentalUnsignedTypes

inline fun ULongArray.lastOrNull(predicate: (ULong) -> Boolean): ULong?

@ExperimentalUnsignedTypes

inline fun UShortArray.lastOrNull(predicate: (UShort) -> Boolean): UShort?

inline fun <T> Iterable<T>.lastOrNull(predicate: (T) -> Boolean): T?

inline fun <T> List<T>.lastOrNull(predicate: (T) -> Boolean): T?

linkedMapOf

inline fun <K, V> linkedMapOf(): LinkedHashMap<K, V>

fun <K, V> linkedMapOf(vararg pairs: Pair<K, V>): LinkedHashMap<K, V>

linkedSetOf

inline fun <T> linkedSetOf(): LinkedHashSet<T>

fun <T> linkedSetOf(vararg elements: T): LinkedHashSet<T>

linkedStringMapOf

fun <V> linkedStringMapOf(vararg pairs: Pair<String, V>): LinkedHashMap<String, V>

linkedStringSetOf

fun linkedStringSetOf(vararg elements: String): LinkedHashSet<String>

List

inline fun <T> List(size: Int, init: (index: Int) -> T): List<T>

listOf

inline fun <T> listOf(): List<T>

fun <T> listOf(element: T): List<T>

fun <T> listOf(vararg elements: T): List<T>

listOfNotNull

fun <T : Any> listOfNotNull(element: T?): List<T>

fun <T : Any> listOfNotNull(vararg elements: T?): List<T>

map

inline fun <T, R> Array<out T>.map(transform: (T) -> R): List<R>

inline fun <R> BooleanArray.map(transform: (Boolean) -> R): List<R>

inline fun <R> ByteArray.map(transform: (Byte) -> R): List<R>

inline fun <R> CharArray.map(transform: (Char) -> R): List<R>

inline fun <R> DoubleArray.map(transform: (Double) -> R): List<R>

inline fun <R> FloatArray.map(transform: (Float) -> R): List<R>

inline fun <R> IntArray.map(transform: (Int) -> R): List<R>

inline fun <R> LongArray.map(transform: (Long) -> R): List<R>

inline fun <R> ShortArray.map(transform: (Short) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UByteArray.map(transform: (UByte) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UIntArray.map(transform: (UInt) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> ULongArray.map(transform: (ULong) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UShortArray.map(transform: (UShort) -> R): List<R>

inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>

inline fun <K, V, R> Map<out K, V>.map(transform: (Map.Entry<K, V>) -> R): List<R>

mapIndexed

inline fun <T, R> Array<out T>.mapIndexed(transform: (index: Int, T) -> R): List<R>

inline fun <R> BooleanArray.mapIndexed(transform: (index: Int, Boolean) -> R): List<R>

inline fun <R> ByteArray.mapIndexed(transform: (index: Int, Byte) -> R): List<R>

inline fun <R> CharArray.mapIndexed(transform: (index: Int, Char) -> R): List<R>

inline fun <R> DoubleArray.mapIndexed(transform: (index: Int, Double) -> R): List<R>

inline fun <R> FloatArray.mapIndexed(transform: (index: Int, Float) -> R): List<R>

inline fun <R> IntArray.mapIndexed(transform: (index: Int, Int) -> R): List<R>

inline fun <R> LongArray.mapIndexed(transform: (index: Int, Long) -> R): List<R>

inline fun <R> ShortArray.mapIndexed(transform: (index: Int, Short) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UByteArray.mapIndexed(transform: (index: Int, UByte) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UIntArray.mapIndexed(transform: (index: Int, UInt) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> ULongArray.mapIndexed(transform: (index: Int, ULong) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UShortArray.mapIndexed(transform: (index: Int, UShort) -> R): List<R>

inline fun <T, R> Iterable<T>.mapIndexed(transform: (index: Int, T) -> R): List<R>

mapIndexedNotNull

inline fun <T, R : Any> Array<out T>.mapIndexedNotNull(transform: (index: Int, T) -> R?): List<R>

inline fun <T, R : Any> Iterable<T>.mapIndexedNotNull(transform: (index: Int, T) -> R?): List<R>

mapIndexedNotNullTo

inline fun <T, R : Any, C : MutableCollection<in R>> Array<out T>.mapIndexedNotNullTo(destination: C, transform: (index: Int, T) -> R?): C

inline fun <T, R : Any, C : MutableCollection<in R>> Iterable<T>.mapIndexedNotNullTo(destination: C, transform: (index: Int, T) -> R?): C

mapIndexedTo

inline fun <T, R, C : MutableCollection<in R>> Array<out T>.mapIndexedTo(destination: C, transform: (index: Int, T) -> R): C

inline fun <R, C : MutableCollection<in R>> BooleanArray.mapIndexedTo(destination: C, transform: (index: Int, Boolean) -> R): C

inline fun <R, C : MutableCollection<in R>> ByteArray.mapIndexedTo(destination: C, transform: (index: Int, Byte) -> R): C

inline fun <R, C : MutableCollection<in R>> CharArray.mapIndexedTo(destination: C, transform: (index: Int, Char) -> R): C

inline fun <R, C : MutableCollection<in R>> DoubleArray.mapIndexedTo(destination: C, transform: (index: Int, Double) -> R): C

inline fun <R, C : MutableCollection<in R>> FloatArray.mapIndexedTo(destination: C, transform: (index: Int, Float) -> R): C

inline fun <R, C : MutableCollection<in R>> IntArray.mapIndexedTo(destination: C, transform: (index: Int, Int) -> R): C

inline fun <R, C : MutableCollection<in R>> LongArray.mapIndexedTo(destination: C, transform: (index: Int, Long) -> R): C

inline fun <R, C : MutableCollection<in R>> ShortArray.mapIndexedTo(destination: C, transform: (index: Int, Short) -> R): C

@ExperimentalUnsignedTypes

inline fun <R, C : MutableCollection<in R>> UByteArray.mapIndexedTo(destination: C, transform: (index: Int, UByte) -> R): C

@ExperimentalUnsignedTypes

inline fun <R, C : MutableCollection<in R>> UIntArray.mapIndexedTo(destination: C, transform: (index: Int, UInt) -> R): C

@ExperimentalUnsignedTypes

inline fun <R, C : MutableCollection<in R>> ULongArray.mapIndexedTo(destination: C, transform: (index: Int, ULong) -> R): C

@ExperimentalUnsignedTypes

inline fun <R, C : MutableCollection<in R>> UShortArray.mapIndexedTo(destination: C, transform: (index: Int, UShort) -> R): C

inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapIndexedTo(destination: C, transform: (index: Int, T) -> R): C

mapKeys

inline fun <K, V, R> Map<out K, V>.mapKeys(transform: (Map.Entry<K, V>) -> R): Map<R, V>

mapKeysTo

inline fun <K, V, R, M : MutableMap<in R, in V>> Map<out K, V>.mapKeysTo(destination: M, transform: (Map.Entry<K, V>) -> R): M

mapNotNull

inline fun <T, R : Any> Array<out T>.mapNotNull(transform: (T) -> R?): List<R>

inline fun <T, R : Any> Iterable<T>.mapNotNull(transform: (T) -> R?): List<R>

inline fun <K, V, R : Any> Map<out K, V>.mapNotNull(transform: (Map.Entry<K, V>) -> R?): List<R>

mapNotNullTo

inline fun <T, R : Any, C : MutableCollection<in R>> Array<out T>.mapNotNullTo(destination: C, transform: (T) -> R?): C

inline fun <T, R : Any, C : MutableCollection<in R>> Iterable<T>.mapNotNullTo(destination: C, transform: (T) -> R?): C

inline fun <K, V, R : Any, C : MutableCollection<in R>> Map<out K, V>.mapNotNullTo(destination: C, transform: (Map.Entry<K, V>) -> R?): C

mapOf

inline fun <K, V> mapOf(): Map<K, V>

fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V>

fun <K, V> mapOf(pair: Pair<K, V>): Map<K, V>

mapTo

inline fun <T, R, C : MutableCollection<in R>> Array<out T>.mapTo(destination: C, transform: (T) -> R): C

inline fun <R, C : MutableCollection<in R>> BooleanArray.mapTo(destination: C, transform: (Boolean) -> R): C

inline fun <R, C : MutableCollection<in R>> ByteArray.mapTo(destination: C, transform: (Byte) -> R): C

inline fun <R, C : MutableCollection<in R>> CharArray.mapTo(destination: C, transform: (Char) -> R): C

inline fun <R, C : MutableCollection<in R>> DoubleArray.mapTo(destination: C, transform: (Double) -> R): C

inline fun <R, C : MutableCollection<in R>> FloatArray.mapTo(destination: C, transform: (Float) -> R): C

inline fun <R, C : MutableCollection<in R>> IntArray.mapTo(destination: C, transform: (Int) -> R): C

inline fun <R, C : MutableCollection<in R>> LongArray.mapTo(destination: C, transform: (Long) -> R): C

inline fun <R, C : MutableCollection<in R>> ShortArray.mapTo(destination: C, transform: (Short) -> R): C

@ExperimentalUnsignedTypes

inline fun <R, C : MutableCollection<in R>> UByteArray.mapTo(destination: C, transform: (UByte) -> R): C

@ExperimentalUnsignedTypes

inline fun <R, C : MutableCollection<in R>> UIntArray.mapTo(destination: C, transform: (UInt) -> R): C

@ExperimentalUnsignedTypes

inline fun <R, C : MutableCollection<in R>> ULongArray.mapTo(destination: C, transform: (ULong) -> R): C

@ExperimentalUnsignedTypes

inline fun <R, C : MutableCollection<in R>> UShortArray.mapTo(destination: C, transform: (UShort) -> R): C

inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapTo(destination: C, transform: (T) -> R): C

inline fun <K, V, R, C : MutableCollection<in R>> Map<out K, V>.mapTo(destination: C, transform: (Map.Entry<K, V>) -> R): C

mapValues

inline fun <K, V, R> Map<out K, V>.mapValues(transform: (Map.Entry<K, V>) -> R): Map<K, R>

mapValuesTo

inline fun <K, V, R, M : MutableMap<in K, in R>> Map<out K, V>.mapValuesTo(destination: M, transform: (Map.Entry<K, V>) -> R): M

max

@JvmName(name = "maxOrThrow")

fun <T : Comparable<T>> Array<out T>.max(): T

@JvmName(name = "maxOrThrow")

fun DoubleArray.max(): Double

@JvmName(name = "maxOrThrow")

fun FloatArray.max(): Float

@JvmName(name = "maxOrThrow")

fun ByteArray.max(): Byte

@JvmName(name = "maxOrThrow")

fun CharArray.max(): Char

@JvmName(name = "maxOrThrow")

fun DoubleArray.max(): Double

@JvmName(name = "maxOrThrow")

fun FloatArray.max(): Float

@JvmName(name = "maxOrThrow")

fun IntArray.max(): Int

@JvmName(name = "maxOrThrow")

fun LongArray.max(): Long

@JvmName(name = "maxOrThrow")

fun ShortArray.max(): Short

@JvmName(name = "maxOrThrow-U")

@ExperimentalUnsignedTypes

fun UByteArray.max(): UByte

@JvmName(name = "maxOrThrow-U")

@ExperimentalUnsignedTypes

fun UIntArray.max(): UInt

@JvmName(name = "maxOrThrow-U")

@ExperimentalUnsignedTypes

fun ULongArray.max(): ULong

@JvmName(name = "maxOrThrow-U")

@ExperimentalUnsignedTypes

fun UShortArray.max(): UShort

@JvmName(name = "maxOrThrow")

fun <T : Comparable<T>> Iterable<T>.max(): T

@JvmName(name = "maxOrThrow")

fun Iterable<Double>.max(): Double

@JvmName(name = "maxOrThrow")

fun Iterable<Float>.max(): Float

maxBy

@JvmName(name = "maxByOrThrow")

inline fun <T, R : Comparable<R>> Array<out T>.maxBy(selector: (T) -> R): T

@JvmName(name = "maxByOrThrow")

inline fun <R : Comparable<R>> BooleanArray.maxBy(selector: (Boolean) -> R): Boolean

@JvmName(name = "maxByOrThrow")

inline fun <R : Comparable<R>> ByteArray.maxBy(selector: (Byte) -> R): Byte

@JvmName(name = "maxByOrThrow")

inline fun <R : Comparable<R>> CharArray.maxBy(selector: (Char) -> R): Char

@JvmName(name = "maxByOrThrow")

inline fun <R : Comparable<R>> DoubleArray.maxBy(selector: (Double) -> R): Double

@JvmName(name = "maxByOrThrow")

inline fun <R : Comparable<R>> FloatArray.maxBy(selector: (Float) -> R): Float

@JvmName(name = "maxByOrThrow")

inline fun <R : Comparable<R>> IntArray.maxBy(selector: (Int) -> R): Int

@JvmName(name = "maxByOrThrow")

inline fun <R : Comparable<R>> LongArray.maxBy(selector: (Long) -> R): Long

@JvmName(name = "maxByOrThrow")

inline fun <R : Comparable<R>> ShortArray.maxBy(selector: (Short) -> R): Short

@JvmName(name = "maxByOrThrow-U")

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UByteArray.maxBy(selector: (UByte) -> R): UByte

@JvmName(name = "maxByOrThrow-U")

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UIntArray.maxBy(selector: (UInt) -> R): UInt

@JvmName(name = "maxByOrThrow-U")

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> ULongArray.maxBy(selector: (ULong) -> R): ULong

@JvmName(name = "maxByOrThrow-U")

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UShortArray.maxBy(selector: (UShort) -> R): UShort

@JvmName(name = "maxByOrThrow")

inline fun <T, R : Comparable<R>> Iterable<T>.maxBy(selector: (T) -> R): T

@JvmName(name = "maxByOrThrow")

inline fun <K, V, R : Comparable<R>> Map<out K, V>.maxBy(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>

maxByOrNull

inline fun <T, R : Comparable<R>> Array<out T>.maxByOrNull(selector: (T) -> R): T?

inline fun <R : Comparable<R>> BooleanArray.maxByOrNull(selector: (Boolean) -> R): Boolean?

inline fun <R : Comparable<R>> ByteArray.maxByOrNull(selector: (Byte) -> R): Byte?

inline fun <R : Comparable<R>> CharArray.maxByOrNull(selector: (Char) -> R): Char?

inline fun <R : Comparable<R>> DoubleArray.maxByOrNull(selector: (Double) -> R): Double?

inline fun <R : Comparable<R>> FloatArray.maxByOrNull(selector: (Float) -> R): Float?

inline fun <R : Comparable<R>> IntArray.maxByOrNull(selector: (Int) -> R): Int?

inline fun <R : Comparable<R>> LongArray.maxByOrNull(selector: (Long) -> R): Long?

inline fun <R : Comparable<R>> ShortArray.maxByOrNull(selector: (Short) -> R): Short?

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UByteArray.maxByOrNull(selector: (UByte) -> R): UByte?

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UIntArray.maxByOrNull(selector: (UInt) -> R): UInt?

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> ULongArray.maxByOrNull(selector: (ULong) -> R): ULong?

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UShortArray.maxByOrNull(selector: (UShort) -> R): UShort?

inline fun <T, R : Comparable<R>> Iterable<T>.maxByOrNull(selector: (T) -> R): T?

inline fun <K, V, R : Comparable<R>> Map<out K, V>.maxByOrNull(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>?

maxOf

inline fun <T, R : Comparable<R>> Array<out T>.maxOf(selector: (T) -> R): R

inline fun <T> Array<out T>.maxOf(selector: (T) -> Double): Double

inline fun <T> Array<out T>.maxOf(selector: (T) -> Float): Float

inline fun <R : Comparable<R>> BooleanArray.maxOf(selector: (Boolean) -> R): R

inline fun BooleanArray.maxOf(selector: (Boolean) -> Double): Double

inline fun BooleanArray.maxOf(selector: (Boolean) -> Float): Float

inline fun <R : Comparable<R>> ByteArray.maxOf(selector: (Byte) -> R): R

inline fun ByteArray.maxOf(selector: (Byte) -> Double): Double

inline fun ByteArray.maxOf(selector: (Byte) -> Float): Float

inline fun <R : Comparable<R>> CharArray.maxOf(selector: (Char) -> R): R

inline fun CharArray.maxOf(selector: (Char) -> Double): Double

inline fun CharArray.maxOf(selector: (Char) -> Float): Float

inline fun <R : Comparable<R>> DoubleArray.maxOf(selector: (Double) -> R): R

inline fun DoubleArray.maxOf(selector: (Double) -> Double): Double

inline fun DoubleArray.maxOf(selector: (Double) -> Float): Float

inline fun <R : Comparable<R>> FloatArray.maxOf(selector: (Float) -> R): R

inline fun FloatArray.maxOf(selector: (Float) -> Double): Double

inline fun FloatArray.maxOf(selector: (Float) -> Float): Float

inline fun <R : Comparable<R>> IntArray.maxOf(selector: (Int) -> R): R

inline fun IntArray.maxOf(selector: (Int) -> Double): Double

inline fun IntArray.maxOf(selector: (Int) -> Float): Float

inline fun <R : Comparable<R>> LongArray.maxOf(selector: (Long) -> R): R

inline fun LongArray.maxOf(selector: (Long) -> Double): Double

inline fun LongArray.maxOf(selector: (Long) -> Float): Float

inline fun <R : Comparable<R>> ShortArray.maxOf(selector: (Short) -> R): R

inline fun ShortArray.maxOf(selector: (Short) -> Double): Double

inline fun ShortArray.maxOf(selector: (Short) -> Float): Float

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UByteArray.maxOf(selector: (UByte) -> R): R

@ExperimentalUnsignedTypes

inline fun UByteArray.maxOf(selector: (UByte) -> Double): Double

@ExperimentalUnsignedTypes

inline fun UByteArray.maxOf(selector: (UByte) -> Float): Float

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UIntArray.maxOf(selector: (UInt) -> R): R

@ExperimentalUnsignedTypes

inline fun UIntArray.maxOf(selector: (UInt) -> Double): Double

@ExperimentalUnsignedTypes

inline fun UIntArray.maxOf(selector: (UInt) -> Float): Float

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> ULongArray.maxOf(selector: (ULong) -> R): R

@ExperimentalUnsignedTypes

inline fun ULongArray.maxOf(selector: (ULong) -> Double): Double

@ExperimentalUnsignedTypes

inline fun ULongArray.maxOf(selector: (ULong) -> Float): Float

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UShortArray.maxOf(selector: (UShort) -> R): R

@ExperimentalUnsignedTypes

inline fun UShortArray.maxOf(selector: (UShort) -> Double): Double

@ExperimentalUnsignedTypes

inline fun UShortArray.maxOf(selector: (UShort) -> Float): Float

inline fun <T, R : Comparable<R>> Iterable<T>.maxOf(selector: (T) -> R): R

inline fun <T> Iterable<T>.maxOf(selector: (T) -> Double): Double

inline fun <T> Iterable<T>.maxOf(selector: (T) -> Float): Float

inline fun <K, V, R : Comparable<R>> Map<out K, V>.maxOf(selector: (Map.Entry<K, V>) -> R): R

inline fun <K, V> Map<out K, V>.maxOf(selector: (Map.Entry<K, V>) -> Double): Double

inline fun <K, V> Map<out K, V>.maxOf(selector: (Map.Entry<K, V>) -> Float): Float

maxOfOrNull

inline fun <T, R : Comparable<R>> Array<out T>.maxOfOrNull(selector: (T) -> R): R?

inline fun <T> Array<out T>.maxOfOrNull(selector: (T) -> Double): Double?

inline fun <T> Array<out T>.maxOfOrNull(selector: (T) -> Float): Float?

inline fun <R : Comparable<R>> BooleanArray.maxOfOrNull(selector: (Boolean) -> R): R?

inline fun BooleanArray.maxOfOrNull(selector: (Boolean) -> Double): Double?

inline fun BooleanArray.maxOfOrNull(selector: (Boolean) -> Float): Float?

inline fun <R : Comparable<R>> ByteArray.maxOfOrNull(selector: (Byte) -> R): R?

inline fun ByteArray.maxOfOrNull(selector: (Byte) -> Double): Double?

inline fun ByteArray.maxOfOrNull(selector: (Byte) -> Float): Float?

inline fun <R : Comparable<R>> CharArray.maxOfOrNull(selector: (Char) -> R): R?

inline fun CharArray.maxOfOrNull(selector: (Char) -> Double): Double?

inline fun CharArray.maxOfOrNull(selector: (Char) -> Float): Float?

inline fun <R : Comparable<R>> DoubleArray.maxOfOrNull(selector: (Double) -> R): R?

inline fun DoubleArray.maxOfOrNull(selector: (Double) -> Double): Double?

inline fun DoubleArray.maxOfOrNull(selector: (Double) -> Float): Float?

inline fun <R : Comparable<R>> FloatArray.maxOfOrNull(selector: (Float) -> R): R?

inline fun FloatArray.maxOfOrNull(selector: (Float) -> Double): Double?

inline fun FloatArray.maxOfOrNull(selector: (Float) -> Float): Float?

inline fun <R : Comparable<R>> IntArray.maxOfOrNull(selector: (Int) -> R): R?

inline fun IntArray.maxOfOrNull(selector: (Int) -> Double): Double?

inline fun IntArray.maxOfOrNull(selector: (Int) -> Float): Float?

inline fun <R : Comparable<R>> LongArray.maxOfOrNull(selector: (Long) -> R): R?

inline fun LongArray.maxOfOrNull(selector: (Long) -> Double): Double?

inline fun LongArray.maxOfOrNull(selector: (Long) -> Float): Float?

inline fun <R : Comparable<R>> ShortArray.maxOfOrNull(selector: (Short) -> R): R?

inline fun ShortArray.maxOfOrNull(selector: (Short) -> Double): Double?

inline fun ShortArray.maxOfOrNull(selector: (Short) -> Float): Float?

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UByteArray.maxOfOrNull(selector: (UByte) -> R): R?

@ExperimentalUnsignedTypes

inline fun UByteArray.maxOfOrNull(selector: (UByte) -> Double): Double?

@ExperimentalUnsignedTypes

inline fun UByteArray.maxOfOrNull(selector: (UByte) -> Float): Float?

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UIntArray.maxOfOrNull(selector: (UInt) -> R): R?

@ExperimentalUnsignedTypes

inline fun UIntArray.maxOfOrNull(selector: (UInt) -> Double): Double?

@ExperimentalUnsignedTypes

inline fun UIntArray.maxOfOrNull(selector: (UInt) -> Float): Float?

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> ULongArray.maxOfOrNull(selector: (ULong) -> R): R?

@ExperimentalUnsignedTypes

inline fun ULongArray.maxOfOrNull(selector: (ULong) -> Double): Double?

@ExperimentalUnsignedTypes

inline fun ULongArray.maxOfOrNull(selector: (ULong) -> Float): Float?

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UShortArray.maxOfOrNull(selector: (UShort) -> R): R?

@ExperimentalUnsignedTypes

inline fun UShortArray.maxOfOrNull(selector: (UShort) -> Double): Double?

@ExperimentalUnsignedTypes

inline fun UShortArray.maxOfOrNull(selector: (UShort) -> Float): Float?

inline fun <T, R : Comparable<R>> Iterable<T>.maxOfOrNull(selector: (T) -> R): R?

inline fun <T> Iterable<T>.maxOfOrNull(selector: (T) -> Double): Double?

inline fun <T> Iterable<T>.maxOfOrNull(selector: (T) -> Float): Float?

inline fun <K, V, R : Comparable<R>> Map<out K, V>.maxOfOrNull(selector: (Map.Entry<K, V>) -> R): R?

inline fun <K, V> Map<out K, V>.maxOfOrNull(selector: (Map.Entry<K, V>) -> Double): Double?

inline fun <K, V> Map<out K, V>.maxOfOrNull(selector: (Map.Entry<K, V>) -> Float): Float?

maxOfWith

inline fun <T, R> Array<out T>.maxOfWith(comparator: Comparator<in R>, selector: (T) -> R): R

inline fun <R> BooleanArray.maxOfWith(comparator: Comparator<in R>, selector: (Boolean) -> R): R

inline fun <R> ByteArray.maxOfWith(comparator: Comparator<in R>, selector: (Byte) -> R): R

inline fun <R> CharArray.maxOfWith(comparator: Comparator<in R>, selector: (Char) -> R): R

inline fun <R> DoubleArray.maxOfWith(comparator: Comparator<in R>, selector: (Double) -> R): R

inline fun <R> FloatArray.maxOfWith(comparator: Comparator<in R>, selector: (Float) -> R): R

inline fun <R> IntArray.maxOfWith(comparator: Comparator<in R>, selector: (Int) -> R): R

inline fun <R> LongArray.maxOfWith(comparator: Comparator<in R>, selector: (Long) -> R): R

inline fun <R> ShortArray.maxOfWith(comparator: Comparator<in R>, selector: (Short) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> UByteArray.maxOfWith(comparator: Comparator<in R>, selector: (UByte) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> UIntArray.maxOfWith(comparator: Comparator<in R>, selector: (UInt) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> ULongArray.maxOfWith(comparator: Comparator<in R>, selector: (ULong) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> UShortArray.maxOfWith(comparator: Comparator<in R>, selector: (UShort) -> R): R

inline fun <T, R> Iterable<T>.maxOfWith(comparator: Comparator<in R>, selector: (T) -> R): R

inline fun <K, V, R> Map<out K, V>.maxOfWith(comparator: Comparator<in R>, selector: (Map.Entry<K, V>) -> R): R

maxOfWithOrNull

inline fun <T, R> Array<out T>.maxOfWithOrNull(comparator: Comparator<in R>, selector: (T) -> R): R?

inline fun <R> BooleanArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Boolean) -> R): R?

inline fun <R> ByteArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Byte) -> R): R?

inline fun <R> CharArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Char) -> R): R?

inline fun <R> DoubleArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Double) -> R): R?

inline fun <R> FloatArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Float) -> R): R?

inline fun <R> IntArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Int) -> R): R?

inline fun <R> LongArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Long) -> R): R?

inline fun <R> ShortArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Short) -> R): R?

@ExperimentalUnsignedTypes

inline fun <R> UByteArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (UByte) -> R): R?

@ExperimentalUnsignedTypes

inline fun <R> UIntArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (UInt) -> R): R?

@ExperimentalUnsignedTypes

inline fun <R> ULongArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (ULong) -> R): R?

@ExperimentalUnsignedTypes

inline fun <R> UShortArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (UShort) -> R): R?

inline fun <T, R> Iterable<T>.maxOfWithOrNull(comparator: Comparator<in R>, selector: (T) -> R): R?

inline fun <K, V, R> Map<out K, V>.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Map.Entry<K, V>) -> R): R?

maxOrNull

fun <T : Comparable<T>> Array<out T>.maxOrNull(): T?

fun DoubleArray.maxOrNull(): Double?

fun FloatArray.maxOrNull(): Float?

fun ByteArray.maxOrNull(): Byte?

fun CharArray.maxOrNull(): Char?

fun DoubleArray.maxOrNull(): Double?

fun FloatArray.maxOrNull(): Float?

fun IntArray.maxOrNull(): Int?

fun LongArray.maxOrNull(): Long?

fun ShortArray.maxOrNull(): Short?

@ExperimentalUnsignedTypes

fun UByteArray.maxOrNull(): UByte?

@ExperimentalUnsignedTypes

fun UIntArray.maxOrNull(): UInt?

@ExperimentalUnsignedTypes

fun ULongArray.maxOrNull(): ULong?

@ExperimentalUnsignedTypes

fun UShortArray.maxOrNull(): UShort?

fun <T : Comparable<T>> Iterable<T>.maxOrNull(): T?

fun Iterable<Double>.maxOrNull(): Double?

fun Iterable<Float>.maxOrNull(): Float?

maxWith

@JvmName(name = "maxWithOrThrow")

fun <T> Array<out T>.maxWith(comparator: Comparator<in T>): T

@JvmName(name = "maxWithOrThrow")

fun BooleanArray.maxWith(comparator: Comparator<in Boolean>): Boolean

@JvmName(name = "maxWithOrThrow")

fun ByteArray.maxWith(comparator: Comparator<in Byte>): Byte

@JvmName(name = "maxWithOrThrow")

fun CharArray.maxWith(comparator: Comparator<in Char>): Char

@JvmName(name = "maxWithOrThrow")

fun DoubleArray.maxWith(comparator: Comparator<in Double>): Double

@JvmName(name = "maxWithOrThrow")

fun FloatArray.maxWith(comparator: Comparator<in Float>): Float

@JvmName(name = "maxWithOrThrow")

fun IntArray.maxWith(comparator: Comparator<in Int>): Int

@JvmName(name = "maxWithOrThrow")

fun LongArray.maxWith(comparator: Comparator<in Long>): Long

@JvmName(name = "maxWithOrThrow")

fun ShortArray.maxWith(comparator: Comparator<in Short>): Short

@JvmName(name = "maxWithOrThrow-U")

@ExperimentalUnsignedTypes

fun UByteArray.maxWith(comparator: Comparator<in UByte>): UByte

@JvmName(name = "maxWithOrThrow-U")

@ExperimentalUnsignedTypes

fun UIntArray.maxWith(comparator: Comparator<in UInt>): UInt

@JvmName(name = "maxWithOrThrow-U")

@ExperimentalUnsignedTypes

fun ULongArray.maxWith(comparator: Comparator<in ULong>): ULong

@JvmName(name = "maxWithOrThrow-U")

@ExperimentalUnsignedTypes

fun UShortArray.maxWith(comparator: Comparator<in UShort>): UShort

@JvmName(name = "maxWithOrThrow")

fun <T> Iterable<T>.maxWith(comparator: Comparator<in T>): T

@JvmName(name = "maxWithOrThrow")

inline fun <K, V> Map<out K, V>.maxWith(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>

maxWithOrNull

fun <T> Array<out T>.maxWithOrNull(comparator: Comparator<in T>): T?

fun BooleanArray.maxWithOrNull(comparator: Comparator<in Boolean>): Boolean?

fun ByteArray.maxWithOrNull(comparator: Comparator<in Byte>): Byte?

fun CharArray.maxWithOrNull(comparator: Comparator<in Char>): Char?

fun DoubleArray.maxWithOrNull(comparator: Comparator<in Double>): Double?

fun FloatArray.maxWithOrNull(comparator: Comparator<in Float>): Float?

fun IntArray.maxWithOrNull(comparator: Comparator<in Int>): Int?

fun LongArray.maxWithOrNull(comparator: Comparator<in Long>): Long?

fun ShortArray.maxWithOrNull(comparator: Comparator<in Short>): Short?

@ExperimentalUnsignedTypes

fun UByteArray.maxWithOrNull(comparator: Comparator<in UByte>): UByte?

@ExperimentalUnsignedTypes

fun UIntArray.maxWithOrNull(comparator: Comparator<in UInt>): UInt?

@ExperimentalUnsignedTypes

fun ULongArray.maxWithOrNull(comparator: Comparator<in ULong>): ULong?

@ExperimentalUnsignedTypes

fun UShortArray.maxWithOrNull(comparator: Comparator<in UShort>): UShort?

fun <T> Iterable<T>.maxWithOrNull(comparator: Comparator<in T>): T?

inline fun <K, V> Map<out K, V>.maxWithOrNull(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>?

min

@JvmName(name = "minOrThrow")

fun <T : Comparable<T>> Array<out T>.min(): T

@JvmName(name = "minOrThrow")

fun DoubleArray.min(): Double

@JvmName(name = "minOrThrow")

fun FloatArray.min(): Float

@JvmName(name = "minOrThrow")

fun ByteArray.min(): Byte

@JvmName(name = "minOrThrow")

fun CharArray.min(): Char

@JvmName(name = "minOrThrow")

fun DoubleArray.min(): Double

@JvmName(name = "minOrThrow")

fun FloatArray.min(): Float

@JvmName(name = "minOrThrow")

fun IntArray.min(): Int

@JvmName(name = "minOrThrow")

fun LongArray.min(): Long

@JvmName(name = "minOrThrow")

fun ShortArray.min(): Short

@JvmName(name = "minOrThrow-U")

@ExperimentalUnsignedTypes

fun UByteArray.min(): UByte

@JvmName(name = "minOrThrow-U")

@ExperimentalUnsignedTypes

fun UIntArray.min(): UInt

@JvmName(name = "minOrThrow-U")

@ExperimentalUnsignedTypes

fun ULongArray.min(): ULong

@JvmName(name = "minOrThrow-U")

@ExperimentalUnsignedTypes

fun UShortArray.min(): UShort

@JvmName(name = "minOrThrow")

fun <T : Comparable<T>> Iterable<T>.min(): T

@JvmName(name = "minOrThrow")

fun Iterable<Double>.min(): Double

@JvmName(name = "minOrThrow")

fun Iterable<Float>.min(): Float

minBy

@JvmName(name = "minByOrThrow")

inline fun <T, R : Comparable<R>> Array<out T>.minBy(selector: (T) -> R): T

@JvmName(name = "minByOrThrow")

inline fun <R : Comparable<R>> BooleanArray.minBy(selector: (Boolean) -> R): Boolean

@JvmName(name = "minByOrThrow")

inline fun <R : Comparable<R>> ByteArray.minBy(selector: (Byte) -> R): Byte

@JvmName(name = "minByOrThrow")

inline fun <R : Comparable<R>> CharArray.minBy(selector: (Char) -> R): Char

@JvmName(name = "minByOrThrow")

inline fun <R : Comparable<R>> DoubleArray.minBy(selector: (Double) -> R): Double

@JvmName(name = "minByOrThrow")

inline fun <R : Comparable<R>> FloatArray.minBy(selector: (Float) -> R): Float

@JvmName(name = "minByOrThrow")

inline fun <R : Comparable<R>> IntArray.minBy(selector: (Int) -> R): Int

@JvmName(name = "minByOrThrow")

inline fun <R : Comparable<R>> LongArray.minBy(selector: (Long) -> R): Long

@JvmName(name = "minByOrThrow")

inline fun <R : Comparable<R>> ShortArray.minBy(selector: (Short) -> R): Short

@JvmName(name = "minByOrThrow-U")

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UByteArray.minBy(selector: (UByte) -> R): UByte

@JvmName(name = "minByOrThrow-U")

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UIntArray.minBy(selector: (UInt) -> R): UInt

@JvmName(name = "minByOrThrow-U")

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> ULongArray.minBy(selector: (ULong) -> R): ULong

@JvmName(name = "minByOrThrow-U")

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UShortArray.minBy(selector: (UShort) -> R): UShort

@JvmName(name = "minByOrThrow")

inline fun <T, R : Comparable<R>> Iterable<T>.minBy(selector: (T) -> R): T

@JvmName(name = "minByOrThrow")

inline fun <K, V, R : Comparable<R>> Map<out K, V>.minBy(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>

minByOrNull

inline fun <T, R : Comparable<R>> Array<out T>.minByOrNull(selector: (T) -> R): T?

inline fun <R : Comparable<R>> BooleanArray.minByOrNull(selector: (Boolean) -> R): Boolean?

inline fun <R : Comparable<R>> ByteArray.minByOrNull(selector: (Byte) -> R): Byte?

inline fun <R : Comparable<R>> CharArray.minByOrNull(selector: (Char) -> R): Char?

inline fun <R : Comparable<R>> DoubleArray.minByOrNull(selector: (Double) -> R): Double?

inline fun <R : Comparable<R>> FloatArray.minByOrNull(selector: (Float) -> R): Float?

inline fun <R : Comparable<R>> IntArray.minByOrNull(selector: (Int) -> R): Int?

inline fun <R : Comparable<R>> LongArray.minByOrNull(selector: (Long) -> R): Long?

inline fun <R : Comparable<R>> ShortArray.minByOrNull(selector: (Short) -> R): Short?

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UByteArray.minByOrNull(selector: (UByte) -> R): UByte?

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UIntArray.minByOrNull(selector: (UInt) -> R): UInt?

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> ULongArray.minByOrNull(selector: (ULong) -> R): ULong?

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UShortArray.minByOrNull(selector: (UShort) -> R): UShort?

inline fun <T, R : Comparable<R>> Iterable<T>.minByOrNull(selector: (T) -> R): T?

inline fun <K, V, R : Comparable<R>> Map<out K, V>.minByOrNull(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>?

minOf

inline fun <T, R : Comparable<R>> Array<out T>.minOf(selector: (T) -> R): R

inline fun <T> Array<out T>.minOf(selector: (T) -> Double): Double

inline fun <T> Array<out T>.minOf(selector: (T) -> Float): Float

inline fun <R : Comparable<R>> BooleanArray.minOf(selector: (Boolean) -> R): R

inline fun BooleanArray.minOf(selector: (Boolean) -> Double): Double

inline fun BooleanArray.minOf(selector: (Boolean) -> Float): Float

inline fun <R : Comparable<R>> ByteArray.minOf(selector: (Byte) -> R): R

inline fun ByteArray.minOf(selector: (Byte) -> Double): Double

inline fun ByteArray.minOf(selector: (Byte) -> Float): Float

inline fun <R : Comparable<R>> CharArray.minOf(selector: (Char) -> R): R

inline fun CharArray.minOf(selector: (Char) -> Double): Double

inline fun CharArray.minOf(selector: (Char) -> Float): Float

inline fun <R : Comparable<R>> DoubleArray.minOf(selector: (Double) -> R): R

inline fun DoubleArray.minOf(selector: (Double) -> Double): Double

inline fun DoubleArray.minOf(selector: (Double) -> Float): Float

inline fun <R : Comparable<R>> FloatArray.minOf(selector: (Float) -> R): R

inline fun FloatArray.minOf(selector: (Float) -> Double): Double

inline fun FloatArray.minOf(selector: (Float) -> Float): Float

inline fun <R : Comparable<R>> IntArray.minOf(selector: (Int) -> R): R

inline fun IntArray.minOf(selector: (Int) -> Double): Double

inline fun IntArray.minOf(selector: (Int) -> Float): Float

inline fun <R : Comparable<R>> LongArray.minOf(selector: (Long) -> R): R

inline fun LongArray.minOf(selector: (Long) -> Double): Double

inline fun LongArray.minOf(selector: (Long) -> Float): Float

inline fun <R : Comparable<R>> ShortArray.minOf(selector: (Short) -> R): R

inline fun ShortArray.minOf(selector: (Short) -> Double): Double

inline fun ShortArray.minOf(selector: (Short) -> Float): Float

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UByteArray.minOf(selector: (UByte) -> R): R

@ExperimentalUnsignedTypes

inline fun UByteArray.minOf(selector: (UByte) -> Double): Double

@ExperimentalUnsignedTypes

inline fun UByteArray.minOf(selector: (UByte) -> Float): Float

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UIntArray.minOf(selector: (UInt) -> R): R

@ExperimentalUnsignedTypes

inline fun UIntArray.minOf(selector: (UInt) -> Double): Double

@ExperimentalUnsignedTypes

inline fun UIntArray.minOf(selector: (UInt) -> Float): Float

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> ULongArray.minOf(selector: (ULong) -> R): R

@ExperimentalUnsignedTypes

inline fun ULongArray.minOf(selector: (ULong) -> Double): Double

@ExperimentalUnsignedTypes

inline fun ULongArray.minOf(selector: (ULong) -> Float): Float

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UShortArray.minOf(selector: (UShort) -> R): R

@ExperimentalUnsignedTypes

inline fun UShortArray.minOf(selector: (UShort) -> Double): Double

@ExperimentalUnsignedTypes

inline fun UShortArray.minOf(selector: (UShort) -> Float): Float

inline fun <T, R : Comparable<R>> Iterable<T>.minOf(selector: (T) -> R): R

inline fun <T> Iterable<T>.minOf(selector: (T) -> Double): Double

inline fun <T> Iterable<T>.minOf(selector: (T) -> Float): Float

inline fun <K, V, R : Comparable<R>> Map<out K, V>.minOf(selector: (Map.Entry<K, V>) -> R): R

inline fun <K, V> Map<out K, V>.minOf(selector: (Map.Entry<K, V>) -> Double): Double

inline fun <K, V> Map<out K, V>.minOf(selector: (Map.Entry<K, V>) -> Float): Float

minOfOrNull

inline fun <T, R : Comparable<R>> Array<out T>.minOfOrNull(selector: (T) -> R): R?

inline fun <T> Array<out T>.minOfOrNull(selector: (T) -> Double): Double?

inline fun <T> Array<out T>.minOfOrNull(selector: (T) -> Float): Float?

inline fun <R : Comparable<R>> BooleanArray.minOfOrNull(selector: (Boolean) -> R): R?

inline fun BooleanArray.minOfOrNull(selector: (Boolean) -> Double): Double?

inline fun BooleanArray.minOfOrNull(selector: (Boolean) -> Float): Float?

inline fun <R : Comparable<R>> ByteArray.minOfOrNull(selector: (Byte) -> R): R?

inline fun ByteArray.minOfOrNull(selector: (Byte) -> Double): Double?

inline fun ByteArray.minOfOrNull(selector: (Byte) -> Float): Float?

inline fun <R : Comparable<R>> CharArray.minOfOrNull(selector: (Char) -> R): R?

inline fun CharArray.minOfOrNull(selector: (Char) -> Double): Double?

inline fun CharArray.minOfOrNull(selector: (Char) -> Float): Float?

inline fun <R : Comparable<R>> DoubleArray.minOfOrNull(selector: (Double) -> R): R?

inline fun DoubleArray.minOfOrNull(selector: (Double) -> Double): Double?

inline fun DoubleArray.minOfOrNull(selector: (Double) -> Float): Float?

inline fun <R : Comparable<R>> FloatArray.minOfOrNull(selector: (Float) -> R): R?

inline fun FloatArray.minOfOrNull(selector: (Float) -> Double): Double?

inline fun FloatArray.minOfOrNull(selector: (Float) -> Float): Float?

inline fun <R : Comparable<R>> IntArray.minOfOrNull(selector: (Int) -> R): R?

inline fun IntArray.minOfOrNull(selector: (Int) -> Double): Double?

inline fun IntArray.minOfOrNull(selector: (Int) -> Float): Float?

inline fun <R : Comparable<R>> LongArray.minOfOrNull(selector: (Long) -> R): R?

inline fun LongArray.minOfOrNull(selector: (Long) -> Double): Double?

inline fun LongArray.minOfOrNull(selector: (Long) -> Float): Float?

inline fun <R : Comparable<R>> ShortArray.minOfOrNull(selector: (Short) -> R): R?

inline fun ShortArray.minOfOrNull(selector: (Short) -> Double): Double?

inline fun ShortArray.minOfOrNull(selector: (Short) -> Float): Float?

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UByteArray.minOfOrNull(selector: (UByte) -> R): R?

@ExperimentalUnsignedTypes

inline fun UByteArray.minOfOrNull(selector: (UByte) -> Double): Double?

@ExperimentalUnsignedTypes

inline fun UByteArray.minOfOrNull(selector: (UByte) -> Float): Float?

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UIntArray.minOfOrNull(selector: (UInt) -> R): R?

@ExperimentalUnsignedTypes

inline fun UIntArray.minOfOrNull(selector: (UInt) -> Double): Double?

@ExperimentalUnsignedTypes

inline fun UIntArray.minOfOrNull(selector: (UInt) -> Float): Float?

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> ULongArray.minOfOrNull(selector: (ULong) -> R): R?

@ExperimentalUnsignedTypes

inline fun ULongArray.minOfOrNull(selector: (ULong) -> Double): Double?

@ExperimentalUnsignedTypes

inline fun ULongArray.minOfOrNull(selector: (ULong) -> Float): Float?

@ExperimentalUnsignedTypes

inline fun <R : Comparable<R>> UShortArray.minOfOrNull(selector: (UShort) -> R): R?

@ExperimentalUnsignedTypes

inline fun UShortArray.minOfOrNull(selector: (UShort) -> Double): Double?

@ExperimentalUnsignedTypes

inline fun UShortArray.minOfOrNull(selector: (UShort) -> Float): Float?

inline fun <T, R : Comparable<R>> Iterable<T>.minOfOrNull(selector: (T) -> R): R?

inline fun <T> Iterable<T>.minOfOrNull(selector: (T) -> Double): Double?

inline fun <T> Iterable<T>.minOfOrNull(selector: (T) -> Float): Float?

inline fun <K, V, R : Comparable<R>> Map<out K, V>.minOfOrNull(selector: (Map.Entry<K, V>) -> R): R?

inline fun <K, V> Map<out K, V>.minOfOrNull(selector: (Map.Entry<K, V>) -> Double): Double?

inline fun <K, V> Map<out K, V>.minOfOrNull(selector: (Map.Entry<K, V>) -> Float): Float?

minOfWith

inline fun <T, R> Array<out T>.minOfWith(comparator: Comparator<in R>, selector: (T) -> R): R

inline fun <R> BooleanArray.minOfWith(comparator: Comparator<in R>, selector: (Boolean) -> R): R

inline fun <R> ByteArray.minOfWith(comparator: Comparator<in R>, selector: (Byte) -> R): R

inline fun <R> CharArray.minOfWith(comparator: Comparator<in R>, selector: (Char) -> R): R

inline fun <R> DoubleArray.minOfWith(comparator: Comparator<in R>, selector: (Double) -> R): R

inline fun <R> FloatArray.minOfWith(comparator: Comparator<in R>, selector: (Float) -> R): R

inline fun <R> IntArray.minOfWith(comparator: Comparator<in R>, selector: (Int) -> R): R

inline fun <R> LongArray.minOfWith(comparator: Comparator<in R>, selector: (Long) -> R): R

inline fun <R> ShortArray.minOfWith(comparator: Comparator<in R>, selector: (Short) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> UByteArray.minOfWith(comparator: Comparator<in R>, selector: (UByte) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> UIntArray.minOfWith(comparator: Comparator<in R>, selector: (UInt) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> ULongArray.minOfWith(comparator: Comparator<in R>, selector: (ULong) -> R): R

@ExperimentalUnsignedTypes

inline fun <R> UShortArray.minOfWith(comparator: Comparator<in R>, selector: (UShort) -> R): R

inline fun <T, R> Iterable<T>.minOfWith(comparator: Comparator<in R>, selector: (T) -> R): R

inline fun <K, V, R> Map<out K, V>.minOfWith(comparator: Comparator<in R>, selector: (Map.Entry<K, V>) -> R): R

minOfWithOrNull

inline fun <T, R> Array<out T>.minOfWithOrNull(comparator: Comparator<in R>, selector: (T) -> R): R?

inline fun <R> BooleanArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Boolean) -> R): R?

inline fun <R> ByteArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Byte) -> R): R?

inline fun <R> CharArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Char) -> R): R?

inline fun <R> DoubleArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Double) -> R): R?

inline fun <R> FloatArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Float) -> R): R?

inline fun <R> IntArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Int) -> R): R?

inline fun <R> LongArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Long) -> R): R?

inline fun <R> ShortArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Short) -> R): R?

@ExperimentalUnsignedTypes

inline fun <R> UByteArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (UByte) -> R): R?

@ExperimentalUnsignedTypes

inline fun <R> UIntArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (UInt) -> R): R?

@ExperimentalUnsignedTypes

inline fun <R> ULongArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (ULong) -> R): R?

@ExperimentalUnsignedTypes

inline fun <R> UShortArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (UShort) -> R): R?

inline fun <T, R> Iterable<T>.minOfWithOrNull(comparator: Comparator<in R>, selector: (T) -> R): R?

inline fun <K, V, R> Map<out K, V>.minOfWithOrNull(comparator: Comparator<in R>, selector: (Map.Entry<K, V>) -> R): R?

minOrNull

fun <T : Comparable<T>> Array<out T>.minOrNull(): T?

fun DoubleArray.minOrNull(): Double?

fun FloatArray.minOrNull(): Float?

fun ByteArray.minOrNull(): Byte?

fun CharArray.minOrNull(): Char?

fun DoubleArray.minOrNull(): Double?

fun FloatArray.minOrNull(): Float?

fun IntArray.minOrNull(): Int?

fun LongArray.minOrNull(): Long?

fun ShortArray.minOrNull(): Short?

@ExperimentalUnsignedTypes

fun UByteArray.minOrNull(): UByte?

@ExperimentalUnsignedTypes

fun UIntArray.minOrNull(): UInt?

@ExperimentalUnsignedTypes

fun ULongArray.minOrNull(): ULong?

@ExperimentalUnsignedTypes

fun UShortArray.minOrNull(): UShort?

fun <T : Comparable<T>> Iterable<T>.minOrNull(): T?

fun Iterable<Double>.minOrNull(): Double?

fun Iterable<Float>.minOrNull(): Float?

minus

operator fun <T> Iterable<T>.minus(element: T): List<T>

operator fun <T> Iterable<T>.minus(elements: Array<out T>): List<T>

operator fun <T> Iterable<T>.minus(elements: Iterable<T>): List<T>

operator fun <T> Iterable<T>.minus(elements: Sequence<T>): List<T>

operator fun <K, V> Map<out K, V>.minus(key: K): Map<K, V>

operator fun <K, V> Map<out K, V>.minus(keys: Array<out K>): Map<K, V>

operator fun <K, V> Map<out K, V>.minus(keys: Iterable<K>): Map<K, V>

operator fun <K, V> Map<out K, V>.minus(keys: Sequence<K>): Map<K, V>

operator fun <T> Set<T>.minus(element: T): Set<T>

operator fun <T> Set<T>.minus(elements: Array<out T>): Set<T>

operator fun <T> Set<T>.minus(elements: Iterable<T>): Set<T>

operator fun <T> Set<T>.minus(elements: Sequence<T>): Set<T>

minusAssign

inline operator fun <T> MutableCollection<in T>.minusAssign(element: T)

inline operator fun <T> MutableCollection<in T>.minusAssign(elements: Array<T>)

inline operator fun <T> MutableCollection<in T>.minusAssign(elements: Iterable<T>)

inline operator fun <T> MutableCollection<in T>.minusAssign(elements: Sequence<T>)

inline operator fun <K, V> MutableMap<K, V>.minusAssign(key: K)

inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Array<out K>)

inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Iterable<K>)

inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Sequence<K>)

minusElement

inline fun <T> Iterable<T>.minusElement(element: T): List<T>

inline fun <T> Set<T>.minusElement(element: T): Set<T>

minWith

@JvmName(name = "minWithOrThrow")

fun <T> Array<out T>.minWith(comparator: Comparator<in T>): T

@JvmName(name = "minWithOrThrow")

fun BooleanArray.minWith(comparator: Comparator<in Boolean>): Boolean

@JvmName(name = "minWithOrThrow")

fun ByteArray.minWith(comparator: Comparator<in Byte>): Byte

@JvmName(name = "minWithOrThrow")

fun CharArray.minWith(comparator: Comparator<in Char>): Char

@JvmName(name = "minWithOrThrow")

fun DoubleArray.minWith(comparator: Comparator<in Double>): Double

@JvmName(name = "minWithOrThrow")

fun FloatArray.minWith(comparator: Comparator<in Float>): Float

@JvmName(name = "minWithOrThrow")

fun IntArray.minWith(comparator: Comparator<in Int>): Int

@JvmName(name = "minWithOrThrow")

fun LongArray.minWith(comparator: Comparator<in Long>): Long

@JvmName(name = "minWithOrThrow")

fun ShortArray.minWith(comparator: Comparator<in Short>): Short

@JvmName(name = "minWithOrThrow-U")

@ExperimentalUnsignedTypes

fun UByteArray.minWith(comparator: Comparator<in UByte>): UByte

@JvmName(name = "minWithOrThrow-U")

@ExperimentalUnsignedTypes

fun UIntArray.minWith(comparator: Comparator<in UInt>): UInt

@JvmName(name = "minWithOrThrow-U")

@ExperimentalUnsignedTypes

fun ULongArray.minWith(comparator: Comparator<in ULong>): ULong

@JvmName(name = "minWithOrThrow-U")

@ExperimentalUnsignedTypes

fun UShortArray.minWith(comparator: Comparator<in UShort>): UShort

@JvmName(name = "minWithOrThrow")

fun <T> Iterable<T>.minWith(comparator: Comparator<in T>): T

@JvmName(name = "minWithOrThrow")

inline fun <K, V> Map<out K, V>.minWith(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>

minWithOrNull

fun <T> Array<out T>.minWithOrNull(comparator: Comparator<in T>): T?

fun BooleanArray.minWithOrNull(comparator: Comparator<in Boolean>): Boolean?

fun ByteArray.minWithOrNull(comparator: Comparator<in Byte>): Byte?

fun CharArray.minWithOrNull(comparator: Comparator<in Char>): Char?

fun DoubleArray.minWithOrNull(comparator: Comparator<in Double>): Double?

fun FloatArray.minWithOrNull(comparator: Comparator<in Float>): Float?

fun IntArray.minWithOrNull(comparator: Comparator<in Int>): Int?

fun LongArray.minWithOrNull(comparator: Comparator<in Long>): Long?

fun ShortArray.minWithOrNull(comparator: Comparator<in Short>): Short?

@ExperimentalUnsignedTypes

fun UByteArray.minWithOrNull(comparator: Comparator<in UByte>): UByte?

@ExperimentalUnsignedTypes

fun UIntArray.minWithOrNull(comparator: Comparator<in UInt>): UInt?

@ExperimentalUnsignedTypes

fun ULongArray.minWithOrNull(comparator: Comparator<in ULong>): ULong?

@ExperimentalUnsignedTypes

fun UShortArray.minWithOrNull(comparator: Comparator<in UShort>): UShort?

fun <T> Iterable<T>.minWithOrNull(comparator: Comparator<in T>): T?

inline fun <K, V> Map<out K, V>.minWithOrNull(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>?

MutableList

inline fun <T> MutableList(size: Int, init: (index: Int) -> T): MutableList<T>

mutableListOf

inline fun <T> mutableListOf(): MutableList<T>

fun <T> mutableListOf(vararg elements: T): MutableList<T>

mutableMapOf

inline fun <K, V> mutableMapOf(): MutableMap<K, V>

fun <K, V> mutableMapOf(vararg pairs: Pair<K, V>): MutableMap<K, V>

mutableSetOf

inline fun <T> mutableSetOf(): MutableSet<T>

fun <T> mutableSetOf(vararg elements: T): MutableSet<T>

none

fun <T> Array<out T>.none(): Boolean

fun BooleanArray.none(): Boolean

fun ByteArray.none(): Boolean

fun CharArray.none(): Boolean

fun DoubleArray.none(): Boolean

fun FloatArray.none(): Boolean

fun IntArray.none(): Boolean

fun LongArray.none(): Boolean

fun ShortArray.none(): Boolean

@ExperimentalUnsignedTypes

inline fun UByteArray.none(): Boolean

@ExperimentalUnsignedTypes

inline fun UIntArray.none(): Boolean

@ExperimentalUnsignedTypes

inline fun ULongArray.none(): Boolean

@ExperimentalUnsignedTypes

inline fun UShortArray.none(): Boolean

fun <T> Iterable<T>.none(): Boolean

fun <K, V> Map<out K, V>.none(): Boolean

inline fun <T> Array<out T>.none(predicate: (T) -> Boolean): Boolean

inline fun BooleanArray.none(predicate: (Boolean) -> Boolean): Boolean

inline fun ByteArray.none(predicate: (Byte) -> Boolean): Boolean

inline fun CharArray.none(predicate: (Char) -> Boolean): Boolean

inline fun DoubleArray.none(predicate: (Double) -> Boolean): Boolean

inline fun FloatArray.none(predicate: (Float) -> Boolean): Boolean

inline fun IntArray.none(predicate: (Int) -> Boolean): Boolean

inline fun LongArray.none(predicate: (Long) -> Boolean): Boolean

inline fun ShortArray.none(predicate: (Short) -> Boolean): Boolean

@ExperimentalUnsignedTypes

inline fun UByteArray.none(predicate: (UByte) -> Boolean): Boolean

@ExperimentalUnsignedTypes

inline fun UIntArray.none(predicate: (UInt) -> Boolean): Boolean

@ExperimentalUnsignedTypes

inline fun ULongArray.none(predicate: (ULong) -> Boolean): Boolean

@ExperimentalUnsignedTypes

inline fun UShortArray.none(predicate: (UShort) -> Boolean): Boolean

inline fun <T> Iterable<T>.none(predicate: (T) -> Boolean): Boolean

inline fun <K, V> Map<out K, V>.none(predicate: (Map.Entry<K, V>) -> Boolean): Boolean

onEach

inline fun <T, C : Iterable<T>> C.onEach(action: (T) -> Unit): C

inline fun <K, V, M : Map<out K, V>> M.onEach(action: (Map.Entry<K, V>) -> Unit): M

inline fun <T> Array<out T>.onEach(action: (T) -> Unit): Array<out T>

inline fun BooleanArray.onEach(action: (Boolean) -> Unit): BooleanArray

inline fun ByteArray.onEach(action: (Byte) -> Unit): ByteArray

inline fun CharArray.onEach(action: (Char) -> Unit): CharArray

inline fun DoubleArray.onEach(action: (Double) -> Unit): DoubleArray

inline fun FloatArray.onEach(action: (Float) -> Unit): FloatArray

inline fun IntArray.onEach(action: (Int) -> Unit): IntArray

inline fun LongArray.onEach(action: (Long) -> Unit): LongArray

inline fun ShortArray.onEach(action: (Short) -> Unit): ShortArray

@ExperimentalUnsignedTypes

inline fun UByteArray.onEach(action: (UByte) -> Unit): UByteArray

@ExperimentalUnsignedTypes

inline fun UIntArray.onEach(action: (UInt) -> Unit): UIntArray

@ExperimentalUnsignedTypes

inline fun ULongArray.onEach(action: (ULong) -> Unit): ULongArray

@ExperimentalUnsignedTypes

inline fun UShortArray.onEach(action: (UShort) -> Unit): UShortArray

onEachIndexed

inline fun <T, C : Iterable<T>> C.onEachIndexed(action: (index: Int, T) -> Unit): C

inline fun <K, V, M : Map<out K, V>> M.onEachIndexed(action: (index: Int, Map.Entry<K, V>) -> Unit): M

inline fun <T> Array<out T>.onEachIndexed(action: (index: Int, T) -> Unit): Array<out T>

inline fun BooleanArray.onEachIndexed(action: (index: Int, Boolean) -> Unit): BooleanArray

inline fun ByteArray.onEachIndexed(action: (index: Int, Byte) -> Unit): ByteArray

inline fun CharArray.onEachIndexed(action: (index: Int, Char) -> Unit): CharArray

inline fun DoubleArray.onEachIndexed(action: (index: Int, Double) -> Unit): DoubleArray

inline fun FloatArray.onEachIndexed(action: (index: Int, Float) -> Unit): FloatArray

inline fun IntArray.onEachIndexed(action: (index: Int, Int) -> Unit): IntArray

inline fun LongArray.onEachIndexed(action: (index: Int, Long) -> Unit): LongArray

inline fun ShortArray.onEachIndexed(action: (index: Int, Short) -> Unit): ShortArray

@ExperimentalUnsignedTypes

inline fun UByteArray.onEachIndexed(action: (index: Int, UByte) -> Unit): UByteArray

@ExperimentalUnsignedTypes

inline fun UIntArray.onEachIndexed(action: (index: Int, UInt) -> Unit): UIntArray

@ExperimentalUnsignedTypes

inline fun ULongArray.onEachIndexed(action: (index: Int, ULong) -> Unit): ULongArray

@ExperimentalUnsignedTypes

inline fun UShortArray.onEachIndexed(action: (index: Int, UShort) -> Unit): UShortArray

orEmpty

inline fun <T> Array<out T>?.orEmpty(): Array<out T>

inline fun <T> Collection<T>?.orEmpty(): Collection<T>

inline fun <T> List<T>?.orEmpty(): List<T>

inline fun <K, V> Map<K, V>?.orEmpty(): Map<K, V>

inline fun <T> Set<T>?.orEmpty(): Set<T>

partition

inline fun <T> Array<out T>.partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>>

inline fun BooleanArray.partition(predicate: (Boolean) -> Boolean): Pair<List<Boolean>, List<Boolean>>

inline fun ByteArray.partition(predicate: (Byte) -> Boolean): Pair<List<Byte>, List<Byte>>

inline fun CharArray.partition(predicate: (Char) -> Boolean): Pair<List<Char>, List<Char>>

inline fun DoubleArray.partition(predicate: (Double) -> Boolean): Pair<List<Double>, List<Double>>

inline fun FloatArray.partition(predicate: (Float) -> Boolean): Pair<List<Float>, List<Float>>

inline fun IntArray.partition(predicate: (Int) -> Boolean): Pair<List<Int>, List<Int>>

inline fun LongArray.partition(predicate: (Long) -> Boolean): Pair<List<Long>, List<Long>>

inline fun ShortArray.partition(predicate: (Short) -> Boolean): Pair<List<Short>, List<Short>>

inline fun <T> Iterable<T>.partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>>

plus

inline operator fun <T> Array<out T>.plus(element: T): Array<T>

inline operator fun <T> Array<out T>.plus(elements: Array<out T>): Array<T>

operator fun <T> Array<out T>.plus(elements: Collection<T>): Array<T>

inline operator fun BooleanArray.plus(element: Boolean): BooleanArray

inline operator fun BooleanArray.plus(elements: BooleanArray): BooleanArray

operator fun BooleanArray.plus(elements: Collection<Boolean>): BooleanArray

inline operator fun ByteArray.plus(element: Byte): ByteArray

inline operator fun ByteArray.plus(elements: ByteArray): ByteArray

operator fun ByteArray.plus(elements: Collection<Byte>): ByteArray

inline operator fun CharArray.plus(element: Char): CharArray

inline operator fun CharArray.plus(elements: CharArray): CharArray

operator fun CharArray.plus(elements: Collection<Char>): CharArray

inline operator fun DoubleArray.plus(element: Double): DoubleArray

inline operator fun DoubleArray.plus(elements: DoubleArray): DoubleArray

operator fun DoubleArray.plus(elements: Collection<Double>): DoubleArray

inline operator fun FloatArray.plus(element: Float): FloatArray

inline operator fun FloatArray.plus(elements: FloatArray): FloatArray

operator fun FloatArray.plus(elements: Collection<Float>): FloatArray

inline operator fun IntArray.plus(element: Int): IntArray

inline operator fun IntArray.plus(elements: IntArray): IntArray

operator fun IntArray.plus(elements: Collection<Int>): IntArray

inline operator fun LongArray.plus(element: Long): LongArray

inline operator fun LongArray.plus(elements: LongArray): LongArray

operator fun LongArray.plus(elements: Collection<Long>): LongArray

inline operator fun ShortArray.plus(element: Short): ShortArray

inline operator fun ShortArray.plus(elements: ShortArray): ShortArray

operator fun ShortArray.plus(elements: Collection<Short>): ShortArray

@ExperimentalUnsignedTypes

inline operator fun UByteArray.plus(element: UByte): UByteArray

@ExperimentalUnsignedTypes

inline operator fun UByteArray.plus(elements: UByteArray): UByteArray

@ExperimentalUnsignedTypes

operator fun UByteArray.plus(elements: Collection<UByte>): UByteArray

@ExperimentalUnsignedTypes

inline operator fun UIntArray.plus(element: UInt): UIntArray

@ExperimentalUnsignedTypes

inline operator fun UIntArray.plus(elements: UIntArray): UIntArray

@ExperimentalUnsignedTypes

operator fun UIntArray.plus(elements: Collection<UInt>): UIntArray

@ExperimentalUnsignedTypes

inline operator fun ULongArray.plus(element: ULong): ULongArray

@ExperimentalUnsignedTypes

inline operator fun ULongArray.plus(elements: ULongArray): ULongArray

@ExperimentalUnsignedTypes

operator fun ULongArray.plus(elements: Collection<ULong>): ULongArray

@ExperimentalUnsignedTypes

inline operator fun UShortArray.plus(element: UShort): UShortArray

@ExperimentalUnsignedTypes

inline operator fun UShortArray.plus(elements: UShortArray): UShortArray

@ExperimentalUnsignedTypes

operator fun UShortArray.plus(elements: Collection<UShort>): UShortArray

operator fun <T> Collection<T>.plus(element: T): List<T>

operator fun <T> Collection<T>.plus(elements: Array<out T>): List<T>

operator fun <T> Collection<T>.plus(elements: Iterable<T>): List<T>

operator fun <T> Collection<T>.plus(elements: Sequence<T>): List<T>

operator fun <T> Iterable<T>.plus(element: T): List<T>

operator fun <T> Iterable<T>.plus(elements: Array<out T>): List<T>

operator fun <T> Iterable<T>.plus(elements: Iterable<T>): List<T>

operator fun <T> Iterable<T>.plus(elements: Sequence<T>): List<T>

operator fun <K, V> Map<out K, V>.plus(pairs: Array<out Pair<K, V>>): Map<K, V>

operator fun <K, V> Map<out K, V>.plus(pair: Pair<K, V>): Map<K, V>

operator fun <K, V> Map<out K, V>.plus(pairs: Iterable<Pair<K, V>>): Map<K, V>

operator fun <K, V> Map<out K, V>.plus(map: Map<out K, V>): Map<K, V>

operator fun <K, V> Map<out K, V>.plus(pairs: Sequence<Pair<K, V>>): Map<K, V>

operator fun <T> Set<T>.plus(element: T): Set<T>

operator fun <T> Set<T>.plus(elements: Array<out T>): Set<T>

operator fun <T> Set<T>.plus(elements: Iterable<T>): Set<T>

operator fun <T> Set<T>.plus(elements: Sequence<T>): Set<T>

plusAssign

inline operator fun <T> MutableCollection<in T>.plusAssign(element: T)

inline operator fun <T> MutableCollection<in T>.plusAssign(elements: Array<T>)

inline operator fun <T> MutableCollection<in T>.plusAssign(elements: Iterable<T>)

inline operator fun <T> MutableCollection<in T>.plusAssign(elements: Sequence<T>)

inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Array<out Pair<K, V>>)

inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pair: Pair<K, V>)

inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Iterable<Pair<K, V>>)

inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(map: Map<K, V>)

inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Sequence<Pair<K, V>>)

plusElement

inline fun <T> Array<out T>.plusElement(element: T): Array<T>

inline fun <T> Collection<T>.plusElement(element: T): List<T>

inline fun <T> Iterable<T>.plusElement(element: T): List<T>

inline fun <T> Set<T>.plusElement(element: T): Set<T>

putAll

fun <K, V> MutableMap<in K, in V>.putAll(pairs: Array<out Pair<K, V>>)

fun <K, V> MutableMap<in K, in V>.putAll(pairs: Iterable<Pair<K, V>>)

fun <K, V> MutableMap<in K, in V>.putAll(pairs: Sequence<Pair<K, V>>)

random

inline fun <T> Array<out T>.random(): T

inline fun BooleanArray.random(): Boolean

inline fun ByteArray.random(): Byte

inline fun CharArray.random(): Char

inline fun DoubleArray.random(): Double

inline fun FloatArray.random(): Float

inline fun IntArray.random(): Int

inline fun LongArray.random(): Long

inline fun ShortArray.random(): Short

@ExperimentalUnsignedTypes

inline fun UByteArray.random(): UByte

@ExperimentalUnsignedTypes

inline fun UIntArray.random(): UInt

@ExperimentalUnsignedTypes

inline fun ULongArray.random(): ULong

@ExperimentalUnsignedTypes

inline fun UShortArray.random(): UShort

inline fun <T> Collection<T>.random(): T

fun <T> Array<out T>.random(random: Random): T

fun BooleanArray.random(random: Random): Boolean

fun ByteArray.random(random: Random): Byte

fun CharArray.random(random: Random): Char

fun DoubleArray.random(random: Random): Double

fun FloatArray.random(random: Random): Float

fun IntArray.random(random: Random): Int

fun LongArray.random(random: Random): Long

fun ShortArray.random(random: Random): Short

@ExperimentalUnsignedTypes

fun UByteArray.random(random: Random): UByte

@ExperimentalUnsignedTypes

fun UIntArray.random(random: Random): UInt

@ExperimentalUnsignedTypes

fun ULongArray.random(random: Random): ULong

@ExperimentalUnsignedTypes

fun UShortArray.random(random: Random): UShort

fun <T> Collection<T>.random(random: Random): T

randomOrNull

inline fun <T> Array<out T>.randomOrNull(): T?

inline fun BooleanArray.randomOrNull(): Boolean?

inline fun ByteArray.randomOrNull(): Byte?

inline fun CharArray.randomOrNull(): Char?

inline fun DoubleArray.randomOrNull(): Double?

inline fun FloatArray.randomOrNull(): Float?

inline fun IntArray.randomOrNull(): Int?

inline fun LongArray.randomOrNull(): Long?

inline fun ShortArray.randomOrNull(): Short?

@ExperimentalUnsignedTypes

inline fun UByteArray.randomOrNull(): UByte?

@ExperimentalUnsignedTypes

inline fun UIntArray.randomOrNull(): UInt?

@ExperimentalUnsignedTypes

inline fun ULongArray.randomOrNull(): ULong?

@ExperimentalUnsignedTypes

inline fun UShortArray.randomOrNull(): UShort?

inline fun <T> Collection<T>.randomOrNull(): T?

fun <T> Array<out T>.randomOrNull(random: Random): T?

fun BooleanArray.randomOrNull(random: Random): Boolean?

fun ByteArray.randomOrNull(random: Random): Byte?

fun CharArray.randomOrNull(random: Random): Char?

fun DoubleArray.randomOrNull(random: Random): Double?

fun FloatArray.randomOrNull(random: Random): Float?

fun IntArray.randomOrNull(random: Random): Int?

fun LongArray.randomOrNull(random: Random): Long?

fun ShortArray.randomOrNull(random: Random): Short?

@ExperimentalUnsignedTypes

fun UByteArray.randomOrNull(random: Random): UByte?

@ExperimentalUnsignedTypes

fun UIntArray.randomOrNull(random: Random): UInt?

@ExperimentalUnsignedTypes

fun ULongArray.randomOrNull(random: Random): ULong?

@ExperimentalUnsignedTypes

fun UShortArray.randomOrNull(random: Random): UShort?

fun <T> Collection<T>.randomOrNull(random: Random): T?

reduce

inline fun <S, T : S> Array<out T>.reduce(operation: (acc: S, T) -> S): S

inline fun BooleanArray.reduce(operation: (acc: Boolean, Boolean) -> Boolean): Boolean

inline fun ByteArray.reduce(operation: (acc: Byte, Byte) -> Byte): Byte

inline fun CharArray.reduce(operation: (acc: Char, Char) -> Char): Char

inline fun DoubleArray.reduce(operation: (acc: Double, Double) -> Double): Double

inline fun FloatArray.reduce(operation: (acc: Float, Float) -> Float): Float

inline fun IntArray.reduce(operation: (acc: Int, Int) -> Int): Int

inline fun LongArray.reduce(operation: (acc: Long, Long) -> Long): Long

inline fun ShortArray.reduce(operation: (acc: Short, Short) -> Short): Short

@ExperimentalUnsignedTypes

inline fun UByteArray.reduce(operation: (acc: UByte, UByte) -> UByte): UByte

@ExperimentalUnsignedTypes

inline fun UIntArray.reduce(operation: (acc: UInt, UInt) -> UInt): UInt

@ExperimentalUnsignedTypes

inline fun ULongArray.reduce(operation: (acc: ULong, ULong) -> ULong): ULong

@ExperimentalUnsignedTypes

inline fun UShortArray.reduce(operation: (acc: UShort, UShort) -> UShort): UShort

inline fun <S, T : S, K> Grouping<T, K>.reduce(operation: (key: K, accumulator: S, element: T) -> S): Map<K, S>

inline fun <S, T : S> Iterable<T>.reduce(operation: (acc: S, T) -> S): S

reduceIndexed

inline fun <S, T : S> Array<out T>.reduceIndexed(operation: (index: Int, acc: S, T) -> S): S

inline fun BooleanArray.reduceIndexed(operation: (index: Int, acc: Boolean, Boolean) -> Boolean): Boolean

inline fun ByteArray.reduceIndexed(operation: (index: Int, acc: Byte, Byte) -> Byte): Byte

inline fun CharArray.reduceIndexed(operation: (index: Int, acc: Char, Char) -> Char): Char

inline fun DoubleArray.reduceIndexed(operation: (index: Int, acc: Double, Double) -> Double): Double

inline fun FloatArray.reduceIndexed(operation: (index: Int, acc: Float, Float) -> Float): Float

inline fun IntArray.reduceIndexed(operation: (index: Int, acc: Int, Int) -> Int): Int

inline fun LongArray.reduceIndexed(operation: (index: Int, acc: Long, Long) -> Long): Long

inline fun ShortArray.reduceIndexed(operation: (index: Int, acc: Short, Short) -> Short): Short

@ExperimentalUnsignedTypes

inline fun UByteArray.reduceIndexed(operation: (index: Int, acc: UByte, UByte) -> UByte): UByte

@ExperimentalUnsignedTypes

inline fun UIntArray.reduceIndexed(operation: (index: Int, acc: UInt, UInt) -> UInt): UInt

@ExperimentalUnsignedTypes

inline fun ULongArray.reduceIndexed(operation: (index: Int, acc: ULong, ULong) -> ULong): ULong

@ExperimentalUnsignedTypes

inline fun UShortArray.reduceIndexed(operation: (index: Int, acc: UShort, UShort) -> UShort): UShort

inline fun <S, T : S> Iterable<T>.reduceIndexed(operation: (index: Int, acc: S, T) -> S): S

reduceIndexedOrNull

inline fun <S, T : S> Array<out T>.reduceIndexedOrNull(operation: (index: Int, acc: S, T) -> S): S?

inline fun BooleanArray.reduceIndexedOrNull(operation: (index: Int, acc: Boolean, Boolean) -> Boolean): Boolean?

inline fun ByteArray.reduceIndexedOrNull(operation: (index: Int, acc: Byte, Byte) -> Byte): Byte?

inline fun CharArray.reduceIndexedOrNull(operation: (index: Int, acc: Char, Char) -> Char): Char?

inline fun DoubleArray.reduceIndexedOrNull(operation: (index: Int, acc: Double, Double) -> Double): Double?

inline fun FloatArray.reduceIndexedOrNull(operation: (index: Int, acc: Float, Float) -> Float): Float?

inline fun IntArray.reduceIndexedOrNull(operation: (index: Int, acc: Int, Int) -> Int): Int?

inline fun LongArray.reduceIndexedOrNull(operation: (index: Int, acc: Long, Long) -> Long): Long?

inline fun ShortArray.reduceIndexedOrNull(operation: (index: Int, acc: Short, Short) -> Short): Short?

@ExperimentalUnsignedTypes

inline fun UByteArray.reduceIndexedOrNull(operation: (index: Int, acc: UByte, UByte) -> UByte): UByte?

@ExperimentalUnsignedTypes

inline fun UIntArray.reduceIndexedOrNull(operation: (index: Int, acc: UInt, UInt) -> UInt): UInt?

@ExperimentalUnsignedTypes

inline fun ULongArray.reduceIndexedOrNull(operation: (index: Int, acc: ULong, ULong) -> ULong): ULong?

@ExperimentalUnsignedTypes

inline fun UShortArray.reduceIndexedOrNull(operation: (index: Int, acc: UShort, UShort) -> UShort): UShort?

inline fun <S, T : S> Iterable<T>.reduceIndexedOrNull(operation: (index: Int, acc: S, T) -> S): S?

reduceOrNull

inline fun <S, T : S> Array<out T>.reduceOrNull(operation: (acc: S, T) -> S): S?

inline fun BooleanArray.reduceOrNull(operation: (acc: Boolean, Boolean) -> Boolean): Boolean?

inline fun ByteArray.reduceOrNull(operation: (acc: Byte, Byte) -> Byte): Byte?

inline fun CharArray.reduceOrNull(operation: (acc: Char, Char) -> Char): Char?

inline fun DoubleArray.reduceOrNull(operation: (acc: Double, Double) -> Double): Double?

inline fun FloatArray.reduceOrNull(operation: (acc: Float, Float) -> Float): Float?

inline fun IntArray.reduceOrNull(operation: (acc: Int, Int) -> Int): Int?

inline fun LongArray.reduceOrNull(operation: (acc: Long, Long) -> Long): Long?

inline fun ShortArray.reduceOrNull(operation: (acc: Short, Short) -> Short): Short?

@ExperimentalUnsignedTypes

inline fun UByteArray.reduceOrNull(operation: (acc: UByte, UByte) -> UByte): UByte?

@ExperimentalUnsignedTypes

inline fun UIntArray.reduceOrNull(operation: (acc: UInt, UInt) -> UInt): UInt?

@ExperimentalUnsignedTypes

inline fun ULongArray.reduceOrNull(operation: (acc: ULong, ULong) -> ULong): ULong?

@ExperimentalUnsignedTypes

inline fun UShortArray.reduceOrNull(operation: (acc: UShort, UShort) -> UShort): UShort?

inline fun <S, T : S> Iterable<T>.reduceOrNull(operation: (acc: S, T) -> S): S?

reduceRight

inline fun <S, T : S> Array<out T>.reduceRight(operation: (T, acc: S) -> S): S

inline fun BooleanArray.reduceRight(operation: (Boolean, acc: Boolean) -> Boolean): Boolean

inline fun ByteArray.reduceRight(operation: (Byte, acc: Byte) -> Byte): Byte

inline fun CharArray.reduceRight(operation: (Char, acc: Char) -> Char): Char

inline fun DoubleArray.reduceRight(operation: (Double, acc: Double) -> Double): Double

inline fun FloatArray.reduceRight(operation: (Float, acc: Float) -> Float): Float

inline fun IntArray.reduceRight(operation: (Int, acc: Int) -> Int): Int

inline fun LongArray.reduceRight(operation: (Long, acc: Long) -> Long): Long

inline fun ShortArray.reduceRight(operation: (Short, acc: Short) -> Short): Short

@ExperimentalUnsignedTypes

inline fun UByteArray.reduceRight(operation: (UByte, acc: UByte) -> UByte): UByte

@ExperimentalUnsignedTypes

inline fun UIntArray.reduceRight(operation: (UInt, acc: UInt) -> UInt): UInt

@ExperimentalUnsignedTypes

inline fun ULongArray.reduceRight(operation: (ULong, acc: ULong) -> ULong): ULong

@ExperimentalUnsignedTypes

inline fun UShortArray.reduceRight(operation: (UShort, acc: UShort) -> UShort): UShort

inline fun <S, T : S> List<T>.reduceRight(operation: (T, acc: S) -> S): S

reduceRightIndexed

inline fun <S, T : S> Array<out T>.reduceRightIndexed(operation: (index: Int, T, acc: S) -> S): S

inline fun BooleanArray.reduceRightIndexed(operation: (index: Int, Boolean, acc: Boolean) -> Boolean): Boolean

inline fun ByteArray.reduceRightIndexed(operation: (index: Int, Byte, acc: Byte) -> Byte): Byte

inline fun CharArray.reduceRightIndexed(operation: (index: Int, Char, acc: Char) -> Char): Char

inline fun DoubleArray.reduceRightIndexed(operation: (index: Int, Double, acc: Double) -> Double): Double

inline fun FloatArray.reduceRightIndexed(operation: (index: Int, Float, acc: Float) -> Float): Float

inline fun IntArray.reduceRightIndexed(operation: (index: Int, Int, acc: Int) -> Int): Int

inline fun LongArray.reduceRightIndexed(operation: (index: Int, Long, acc: Long) -> Long): Long

inline fun ShortArray.reduceRightIndexed(operation: (index: Int, Short, acc: Short) -> Short): Short

@ExperimentalUnsignedTypes

inline fun UByteArray.reduceRightIndexed(operation: (index: Int, UByte, acc: UByte) -> UByte): UByte

@ExperimentalUnsignedTypes

inline fun UIntArray.reduceRightIndexed(operation: (index: Int, UInt, acc: UInt) -> UInt): UInt

@ExperimentalUnsignedTypes

inline fun ULongArray.reduceRightIndexed(operation: (index: Int, ULong, acc: ULong) -> ULong): ULong

@ExperimentalUnsignedTypes

inline fun UShortArray.reduceRightIndexed(operation: (index: Int, UShort, acc: UShort) -> UShort): UShort

inline fun <S, T : S> List<T>.reduceRightIndexed(operation: (index: Int, T, acc: S) -> S): S

reduceRightIndexedOrNull

inline fun <S, T : S> Array<out T>.reduceRightIndexedOrNull(operation: (index: Int, T, acc: S) -> S): S?

inline fun BooleanArray.reduceRightIndexedOrNull(operation: (index: Int, Boolean, acc: Boolean) -> Boolean): Boolean?

inline fun ByteArray.reduceRightIndexedOrNull(operation: (index: Int, Byte, acc: Byte) -> Byte): Byte?

inline fun CharArray.reduceRightIndexedOrNull(operation: (index: Int, Char, acc: Char) -> Char): Char?

inline fun DoubleArray.reduceRightIndexedOrNull(operation: (index: Int, Double, acc: Double) -> Double): Double?

inline fun FloatArray.reduceRightIndexedOrNull(operation: (index: Int, Float, acc: Float) -> Float): Float?

inline fun IntArray.reduceRightIndexedOrNull(operation: (index: Int, Int, acc: Int) -> Int): Int?

inline fun LongArray.reduceRightIndexedOrNull(operation: (index: Int, Long, acc: Long) -> Long): Long?

inline fun ShortArray.reduceRightIndexedOrNull(operation: (index: Int, Short, acc: Short) -> Short): Short?

@ExperimentalUnsignedTypes

inline fun UByteArray.reduceRightIndexedOrNull(operation: (index: Int, UByte, acc: UByte) -> UByte): UByte?

@ExperimentalUnsignedTypes

inline fun UIntArray.reduceRightIndexedOrNull(operation: (index: Int, UInt, acc: UInt) -> UInt): UInt?

@ExperimentalUnsignedTypes

inline fun ULongArray.reduceRightIndexedOrNull(operation: (index: Int, ULong, acc: ULong) -> ULong): ULong?

@ExperimentalUnsignedTypes

inline fun UShortArray.reduceRightIndexedOrNull(operation: (index: Int, UShort, acc: UShort) -> UShort): UShort?

inline fun <S, T : S> List<T>.reduceRightIndexedOrNull(operation: (index: Int, T, acc: S) -> S): S?

reduceRightOrNull

inline fun <S, T : S> Array<out T>.reduceRightOrNull(operation: (T, acc: S) -> S): S?

inline fun BooleanArray.reduceRightOrNull(operation: (Boolean, acc: Boolean) -> Boolean): Boolean?

inline fun ByteArray.reduceRightOrNull(operation: (Byte, acc: Byte) -> Byte): Byte?

inline fun CharArray.reduceRightOrNull(operation: (Char, acc: Char) -> Char): Char?

inline fun DoubleArray.reduceRightOrNull(operation: (Double, acc: Double) -> Double): Double?

inline fun FloatArray.reduceRightOrNull(operation: (Float, acc: Float) -> Float): Float?

inline fun IntArray.reduceRightOrNull(operation: (Int, acc: Int) -> Int): Int?

inline fun LongArray.reduceRightOrNull(operation: (Long, acc: Long) -> Long): Long?

inline fun ShortArray.reduceRightOrNull(operation: (Short, acc: Short) -> Short): Short?

@ExperimentalUnsignedTypes

inline fun UByteArray.reduceRightOrNull(operation: (UByte, acc: UByte) -> UByte): UByte?

@ExperimentalUnsignedTypes

inline fun UIntArray.reduceRightOrNull(operation: (UInt, acc: UInt) -> UInt): UInt?

@ExperimentalUnsignedTypes

inline fun ULongArray.reduceRightOrNull(operation: (ULong, acc: ULong) -> ULong): ULong?

@ExperimentalUnsignedTypes

inline fun UShortArray.reduceRightOrNull(operation: (UShort, acc: UShort) -> UShort): UShort?

inline fun <S, T : S> List<T>.reduceRightOrNull(operation: (T, acc: S) -> S): S?

reduceTo

inline fun <S, T : S, K, M : MutableMap<in K, S>> Grouping<T, K>.reduceTo(destination: M, operation: (key: K, accumulator: S, element: T) -> S): M

remove

inline fun <T> MutableCollection<out T>.remove(element: T): Boolean

~~inline~~ ~~fun~~ <T> MutableList<T>.~~remove~~(index: Int): T

inline fun <K, V> MutableMap<out K, V>.remove(key: K): V?

removeAll

fun <T> MutableCollection<in T>.removeAll(elements: Array<out T>): Boolean

inline fun <T> MutableCollection<out T>.removeAll(elements: Collection<T>): Boolean

fun <T> MutableCollection<in T>.removeAll(elements: Iterable<T>): Boolean

fun <T> MutableCollection<in T>.removeAll(elements: Sequence<T>): Boolean

fun <T> MutableIterable<T>.removeAll(predicate: (T) -> Boolean): Boolean

fun <T> MutableList<T>.removeAll(predicate: (T) -> Boolean): Boolean

removeFirst

fun <T> MutableList<T>.removeFirst(): T

removeFirstOrNull

fun <T> MutableList<T>.removeFirstOrNull(): T?

removeLast

fun <T> MutableList<T>.removeLast(): T

removeLastOrNull

fun <T> MutableList<T>.removeLastOrNull(): T?

requireNoNulls

fun <T : Any> Array<T?>.requireNoNulls(): Array<T>

fun <T : Any> Iterable<T?>.requireNoNulls(): Iterable<T>

fun <T : Any> List<T?>.requireNoNulls(): List<T>

retainAll

fun <T> MutableCollection<in T>.retainAll(elements: Array<out T>): Boolean

inline fun <T> MutableCollection<out T>.retainAll(elements: Collection<T>): Boolean

fun <T> MutableCollection<in T>.retainAll(elements: Iterable<T>): Boolean

fun <T> MutableCollection<in T>.retainAll(elements: Sequence<T>): Boolean

fun <T> MutableIterable<T>.retainAll(predicate: (T) -> Boolean): Boolean

fun <T> MutableList<T>.retainAll(predicate: (T) -> Boolean): Boolean

reverse

fun <T> Array<T>.reverse()

fun BooleanArray.reverse()

fun ByteArray.reverse()

fun CharArray.reverse()

fun DoubleArray.reverse()

fun FloatArray.reverse()

fun IntArray.reverse()

fun LongArray.reverse()

fun ShortArray.reverse()

@ExperimentalUnsignedTypes

inline fun UByteArray.reverse()

@ExperimentalUnsignedTypes

inline fun UIntArray.reverse()

@ExperimentalUnsignedTypes

inline fun ULongArray.reverse()

@ExperimentalUnsignedTypes

inline fun UShortArray.reverse()

fun <T> MutableList<T>.reverse()

fun <T> Array<T>.reverse(fromIndex: Int, toIndex: Int)

fun BooleanArray.reverse(fromIndex: Int, toIndex: Int)

fun ByteArray.reverse(fromIndex: Int, toIndex: Int)

fun CharArray.reverse(fromIndex: Int, toIndex: Int)

fun DoubleArray.reverse(fromIndex: Int, toIndex: Int)

fun FloatArray.reverse(fromIndex: Int, toIndex: Int)

fun IntArray.reverse(fromIndex: Int, toIndex: Int)

fun LongArray.reverse(fromIndex: Int, toIndex: Int)

fun ShortArray.reverse(fromIndex: Int, toIndex: Int)

@ExperimentalUnsignedTypes

inline fun UByteArray.reverse(fromIndex: Int, toIndex: Int)

@ExperimentalUnsignedTypes

inline fun UIntArray.reverse(fromIndex: Int, toIndex: Int)

@ExperimentalUnsignedTypes

inline fun ULongArray.reverse(fromIndex: Int, toIndex: Int)

@ExperimentalUnsignedTypes

inline fun UShortArray.reverse(fromIndex: Int, toIndex: Int)

reversed

fun <T> Array<out T>.reversed(): List<T>

fun BooleanArray.reversed(): List<Boolean>

fun ByteArray.reversed(): List<Byte>

fun CharArray.reversed(): List<Char>

fun DoubleArray.reversed(): List<Double>

fun FloatArray.reversed(): List<Float>

fun IntArray.reversed(): List<Int>

fun LongArray.reversed(): List<Long>

fun ShortArray.reversed(): List<Short>

@ExperimentalUnsignedTypes

fun UByteArray.reversed(): List<UByte>

@ExperimentalUnsignedTypes

fun UIntArray.reversed(): List<UInt>

@ExperimentalUnsignedTypes

fun ULongArray.reversed(): List<ULong>

@ExperimentalUnsignedTypes

fun UShortArray.reversed(): List<UShort>

fun <T> Iterable<T>.reversed(): List<T>

reversedArray

fun <T> Array<T>.reversedArray(): Array<T>

fun BooleanArray.reversedArray(): BooleanArray

fun ByteArray.reversedArray(): ByteArray

fun CharArray.reversedArray(): CharArray

fun DoubleArray.reversedArray(): DoubleArray

fun FloatArray.reversedArray(): FloatArray

fun IntArray.reversedArray(): IntArray

fun LongArray.reversedArray(): LongArray

fun ShortArray.reversedArray(): ShortArray

@ExperimentalUnsignedTypes

inline fun UByteArray.reversedArray(): UByteArray

@ExperimentalUnsignedTypes

inline fun UIntArray.reversedArray(): UIntArray

@ExperimentalUnsignedTypes

inline fun ULongArray.reversedArray(): ULongArray

@ExperimentalUnsignedTypes

inline fun UShortArray.reversedArray(): UShortArray

runningFold

inline fun <T, R> Array<out T>.runningFold(initial: R, operation: (acc: R, T) -> R): List<R>

inline fun <R> BooleanArray.runningFold(initial: R, operation: (acc: R, Boolean) -> R): List<R>

inline fun <R> ByteArray.runningFold(initial: R, operation: (acc: R, Byte) -> R): List<R>

inline fun <R> CharArray.runningFold(initial: R, operation: (acc: R, Char) -> R): List<R>

inline fun <R> DoubleArray.runningFold(initial: R, operation: (acc: R, Double) -> R): List<R>

inline fun <R> FloatArray.runningFold(initial: R, operation: (acc: R, Float) -> R): List<R>

inline fun <R> IntArray.runningFold(initial: R, operation: (acc: R, Int) -> R): List<R>

inline fun <R> LongArray.runningFold(initial: R, operation: (acc: R, Long) -> R): List<R>

inline fun <R> ShortArray.runningFold(initial: R, operation: (acc: R, Short) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UByteArray.runningFold(initial: R, operation: (acc: R, UByte) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UIntArray.runningFold(initial: R, operation: (acc: R, UInt) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> ULongArray.runningFold(initial: R, operation: (acc: R, ULong) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UShortArray.runningFold(initial: R, operation: (acc: R, UShort) -> R): List<R>

inline fun <T, R> Iterable<T>.runningFold(initial: R, operation: (acc: R, T) -> R): List<R>

runningFoldIndexed

inline fun <T, R> Array<out T>.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): List<R>

inline fun <R> BooleanArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Boolean) -> R): List<R>

inline fun <R> ByteArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Byte) -> R): List<R>

inline fun <R> CharArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Char) -> R): List<R>

inline fun <R> DoubleArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Double) -> R): List<R>

inline fun <R> FloatArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Float) -> R): List<R>

inline fun <R> IntArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Int) -> R): List<R>

inline fun <R> LongArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Long) -> R): List<R>

inline fun <R> ShortArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Short) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UByteArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, UByte) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UIntArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, UInt) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> ULongArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, ULong) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UShortArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, UShort) -> R): List<R>

inline fun <T, R> Iterable<T>.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): List<R>

runningReduce

inline fun <S, T : S> Array<out T>.runningReduce(operation: (acc: S, T) -> S): List<S>

inline fun BooleanArray.runningReduce(operation: (acc: Boolean, Boolean) -> Boolean): List<Boolean>

inline fun ByteArray.runningReduce(operation: (acc: Byte, Byte) -> Byte): List<Byte>

inline fun CharArray.runningReduce(operation: (acc: Char, Char) -> Char): List<Char>

inline fun DoubleArray.runningReduce(operation: (acc: Double, Double) -> Double): List<Double>

inline fun FloatArray.runningReduce(operation: (acc: Float, Float) -> Float): List<Float>

inline fun IntArray.runningReduce(operation: (acc: Int, Int) -> Int): List<Int>

inline fun LongArray.runningReduce(operation: (acc: Long, Long) -> Long): List<Long>

inline fun ShortArray.runningReduce(operation: (acc: Short, Short) -> Short): List<Short>

@ExperimentalUnsignedTypes

inline fun UByteArray.runningReduce(operation: (acc: UByte, UByte) -> UByte): List<UByte>

@ExperimentalUnsignedTypes

inline fun UIntArray.runningReduce(operation: (acc: UInt, UInt) -> UInt): List<UInt>

@ExperimentalUnsignedTypes

inline fun ULongArray.runningReduce(operation: (acc: ULong, ULong) -> ULong): List<ULong>

@ExperimentalUnsignedTypes

inline fun UShortArray.runningReduce(operation: (acc: UShort, UShort) -> UShort): List<UShort>

inline fun <S, T : S> Iterable<T>.runningReduce(operation: (acc: S, T) -> S): List<S>

runningReduceIndexed

inline fun <S, T : S> Array<out T>.runningReduceIndexed(operation: (index: Int, acc: S, T) -> S): List<S>

inline fun BooleanArray.runningReduceIndexed(operation: (index: Int, acc: Boolean, Boolean) -> Boolean): List<Boolean>

inline fun ByteArray.runningReduceIndexed(operation: (index: Int, acc: Byte, Byte) -> Byte): List<Byte>

inline fun CharArray.runningReduceIndexed(operation: (index: Int, acc: Char, Char) -> Char): List<Char>

inline fun DoubleArray.runningReduceIndexed(operation: (index: Int, acc: Double, Double) -> Double): List<Double>

inline fun FloatArray.runningReduceIndexed(operation: (index: Int, acc: Float, Float) -> Float): List<Float>

inline fun IntArray.runningReduceIndexed(operation: (index: Int, acc: Int, Int) -> Int): List<Int>

inline fun LongArray.runningReduceIndexed(operation: (index: Int, acc: Long, Long) -> Long): List<Long>

inline fun ShortArray.runningReduceIndexed(operation: (index: Int, acc: Short, Short) -> Short): List<Short>

@ExperimentalUnsignedTypes

inline fun UByteArray.runningReduceIndexed(operation: (index: Int, acc: UByte, UByte) -> UByte): List<UByte>

@ExperimentalUnsignedTypes

inline fun UIntArray.runningReduceIndexed(operation: (index: Int, acc: UInt, UInt) -> UInt): List<UInt>

@ExperimentalUnsignedTypes

inline fun ULongArray.runningReduceIndexed(operation: (index: Int, acc: ULong, ULong) -> ULong): List<ULong>

@ExperimentalUnsignedTypes

inline fun UShortArray.runningReduceIndexed(operation: (index: Int, acc: UShort, UShort) -> UShort): List<UShort>

inline fun <S, T : S> Iterable<T>.runningReduceIndexed(operation: (index: Int, acc: S, T) -> S): List<S>

scan

inline fun <T, R> Array<out T>.scan(initial: R, operation: (acc: R, T) -> R): List<R>

inline fun <R> BooleanArray.scan(initial: R, operation: (acc: R, Boolean) -> R): List<R>

inline fun <R> ByteArray.scan(initial: R, operation: (acc: R, Byte) -> R): List<R>

inline fun <R> CharArray.scan(initial: R, operation: (acc: R, Char) -> R): List<R>

inline fun <R> DoubleArray.scan(initial: R, operation: (acc: R, Double) -> R): List<R>

inline fun <R> FloatArray.scan(initial: R, operation: (acc: R, Float) -> R): List<R>

inline fun <R> IntArray.scan(initial: R, operation: (acc: R, Int) -> R): List<R>

inline fun <R> LongArray.scan(initial: R, operation: (acc: R, Long) -> R): List<R>

inline fun <R> ShortArray.scan(initial: R, operation: (acc: R, Short) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UByteArray.scan(initial: R, operation: (acc: R, UByte) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UIntArray.scan(initial: R, operation: (acc: R, UInt) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> ULongArray.scan(initial: R, operation: (acc: R, ULong) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UShortArray.scan(initial: R, operation: (acc: R, UShort) -> R): List<R>

inline fun <T, R> Iterable<T>.scan(initial: R, operation: (acc: R, T) -> R): List<R>

scanIndexed

inline fun <T, R> Array<out T>.scanIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): List<R>

inline fun <R> BooleanArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Boolean) -> R): List<R>

inline fun <R> ByteArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Byte) -> R): List<R>

inline fun <R> CharArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Char) -> R): List<R>

inline fun <R> DoubleArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Double) -> R): List<R>

inline fun <R> FloatArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Float) -> R): List<R>

inline fun <R> IntArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Int) -> R): List<R>

inline fun <R> LongArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Long) -> R): List<R>

inline fun <R> ShortArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Short) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UByteArray.scanIndexed(initial: R, operation: (index: Int, acc: R, UByte) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UIntArray.scanIndexed(initial: R, operation: (index: Int, acc: R, UInt) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> ULongArray.scanIndexed(initial: R, operation: (index: Int, acc: R, ULong) -> R): List<R>

@ExperimentalUnsignedTypes

inline fun <R> UShortArray.scanIndexed(initial: R, operation: (index: Int, acc: R, UShort) -> R): List<R>

inline fun <T, R> Iterable<T>.scanIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): List<R>

set

inline operator fun <K, V> MutableMap<K, V>.set(key: K, value: V)

setOf

inline fun <T> setOf(): Set<T>

fun <T> setOf(element: T): Set<T>

fun <T> setOf(vararg elements: T): Set<T>

setOfNotNull

fun <T : Any> setOfNotNull(element: T?): Set<T>

fun <T : Any> setOfNotNull(vararg elements: T?): Set<T>

setValue

inline operator fun <V> MutableMap<in String, in V>.setValue( thisRef: Any?, property: KProperty<*>, value: V)

shuffle

fun <T> Array<T>.shuffle()

fun BooleanArray.shuffle()

fun ByteArray.shuffle()

fun CharArray.shuffle()

fun DoubleArray.shuffle()

fun FloatArray.shuffle()

fun IntArray.shuffle()

fun LongArray.shuffle()

fun ShortArray.shuffle()

@ExperimentalUnsignedTypes

fun UByteArray.shuffle()

@ExperimentalUnsignedTypes

fun UIntArray.shuffle()

@ExperimentalUnsignedTypes

fun ULongArray.shuffle()

@ExperimentalUnsignedTypes

fun UShortArray.shuffle()

fun <T> MutableList<T>.shuffle()

fun <T> Array<T>.shuffle(random: Random)

fun BooleanArray.shuffle(random: Random)

fun ByteArray.shuffle(random: Random)

fun CharArray.shuffle(random: Random)

fun DoubleArray.shuffle(random: Random)

fun FloatArray.shuffle(random: Random)

fun IntArray.shuffle(random: Random)

fun LongArray.shuffle(random: Random)

fun ShortArray.shuffle(random: Random)

@ExperimentalUnsignedTypes

fun UByteArray.shuffle(random: Random)

@ExperimentalUnsignedTypes

fun UIntArray.shuffle(random: Random)

@ExperimentalUnsignedTypes

fun ULongArray.shuffle(random: Random)

@ExperimentalUnsignedTypes

fun UShortArray.shuffle(random: Random)

fun <T> MutableList<T>.shuffle(random: Random)

shuffled

fun <T> Iterable<T>.shuffled(): List<T>

fun <T> Iterable<T>.shuffled(random: Random): List<T>

single

fun <T> Array<out T>.single(): T

fun BooleanArray.single(): Boolean

fun ByteArray.single(): Byte

fun CharArray.single(): Char

fun DoubleArray.single(): Double

fun FloatArray.single(): Float

fun IntArray.single(): Int

fun LongArray.single(): Long

fun ShortArray.single(): Short

@ExperimentalUnsignedTypes

inline fun UByteArray.single(): UByte

@ExperimentalUnsignedTypes

inline fun UIntArray.single(): UInt

@ExperimentalUnsignedTypes

inline fun ULongArray.single(): ULong

@ExperimentalUnsignedTypes

inline fun UShortArray.single(): UShort

fun <T> Iterable<T>.single(): T

fun <T> List<T>.single(): T

inline fun <T> Array<out T>.single(predicate: (T) -> Boolean): T

inline fun BooleanArray.single(predicate: (Boolean) -> Boolean): Boolean

inline fun ByteArray.single(predicate: (Byte) -> Boolean): Byte

inline fun CharArray.single(predicate: (Char) -> Boolean): Char

inline fun DoubleArray.single(predicate: (Double) -> Boolean): Double

inline fun FloatArray.single(predicate: (Float) -> Boolean): Float

inline fun IntArray.single(predicate: (Int) -> Boolean): Int

inline fun LongArray.single(predicate: (Long) -> Boolean): Long

inline fun ShortArray.single(predicate: (Short) -> Boolean): Short

@ExperimentalUnsignedTypes

inline fun UByteArray.single(predicate: (UByte) -> Boolean): UByte

@ExperimentalUnsignedTypes

inline fun UIntArray.single(predicate: (UInt) -> Boolean): UInt

@ExperimentalUnsignedTypes

inline fun ULongArray.single(predicate: (ULong) -> Boolean): ULong

@ExperimentalUnsignedTypes

inline fun UShortArray.single(predicate: (UShort) -> Boolean): UShort

inline fun <T> Iterable<T>.single(predicate: (T) -> Boolean): T

singleOrNull

fun <T> Array<out T>.singleOrNull(): T?

fun BooleanArray.singleOrNull(): Boolean?

fun ByteArray.singleOrNull(): Byte?

fun CharArray.singleOrNull(): Char?

fun DoubleArray.singleOrNull(): Double?

fun FloatArray.singleOrNull(): Float?

fun IntArray.singleOrNull(): Int?

fun LongArray.singleOrNull(): Long?

fun ShortArray.singleOrNull(): Short?

@ExperimentalUnsignedTypes

fun UByteArray.singleOrNull(): UByte?

@ExperimentalUnsignedTypes

fun UIntArray.singleOrNull(): UInt?

@ExperimentalUnsignedTypes

fun ULongArray.singleOrNull(): ULong?

@ExperimentalUnsignedTypes

fun UShortArray.singleOrNull(): UShort?

fun <T> Iterable<T>.singleOrNull(): T?

fun <T> List<T>.singleOrNull(): T?

inline fun <T> Array<out T>.singleOrNull(predicate: (T) -> Boolean): T?

inline fun BooleanArray.singleOrNull(predicate: (Boolean) -> Boolean): Boolean?

inline fun ByteArray.singleOrNull(predicate: (Byte) -> Boolean): Byte?

inline fun CharArray.singleOrNull(predicate: (Char) -> Boolean): Char?

inline fun DoubleArray.singleOrNull(predicate: (Double) -> Boolean): Double?

inline fun FloatArray.singleOrNull(predicate: (Float) -> Boolean): Float?

inline fun IntArray.singleOrNull(predicate: (Int) -> Boolean): Int?

inline fun LongArray.singleOrNull(predicate: (Long) -> Boolean): Long?

inline fun ShortArray.singleOrNull(predicate: (Short) -> Boolean): Short?

@ExperimentalUnsignedTypes

inline fun UByteArray.singleOrNull(predicate: (UByte) -> Boolean): UByte?

@ExperimentalUnsignedTypes

inline fun UIntArray.singleOrNull(predicate: (UInt) -> Boolean): UInt?

@ExperimentalUnsignedTypes

inline fun ULongArray.singleOrNull(predicate: (ULong) -> Boolean): ULong?

@ExperimentalUnsignedTypes

inline fun UShortArray.singleOrNull(predicate: (UShort) -> Boolean): UShort?

inline fun <T> Iterable<T>.singleOrNull(predicate: (T) -> Boolean): T?

slice

fun <T> Array<out T>.slice(indices: Iterable<Int>): List<T>

fun <T> Array<out T>.slice(indices: IntRange): List<T>

fun BooleanArray.slice(indices: Iterable<Int>): List<Boolean>

fun BooleanArray.slice(indices: IntRange): List<Boolean>

fun ByteArray.slice(indices: Iterable<Int>): List<Byte>

fun ByteArray.slice(indices: IntRange): List<Byte>

fun CharArray.slice(indices: Iterable<Int>): List<Char>

fun CharArray.slice(indices: IntRange): List<Char>

fun DoubleArray.slice(indices: Iterable<Int>): List<Double>

fun DoubleArray.slice(indices: IntRange): List<Double>

fun FloatArray.slice(indices: Iterable<Int>): List<Float>

fun FloatArray.slice(indices: IntRange): List<Float>

fun IntArray.slice(indices: Iterable<Int>): List<Int>

fun IntArray.slice(indices: IntRange): List<Int>

fun LongArray.slice(indices: Iterable<Int>): List<Long>

fun LongArray.slice(indices: IntRange): List<Long>

fun ShortArray.slice(indices: Iterable<Int>): List<Short>

fun ShortArray.slice(indices: IntRange): List<Short>

@ExperimentalUnsignedTypes

fun UByteArray.slice(indices: Iterable<Int>): List<UByte>

@ExperimentalUnsignedTypes

fun UByteArray.slice(indices: IntRange): List<UByte>

@ExperimentalUnsignedTypes

fun UIntArray.slice(indices: Iterable<Int>): List<UInt>

@ExperimentalUnsignedTypes

fun UIntArray.slice(indices: IntRange): List<UInt>

@ExperimentalUnsignedTypes

fun ULongArray.slice(indices: Iterable<Int>): List<ULong>

@ExperimentalUnsignedTypes

fun ULongArray.slice(indices: IntRange): List<ULong>

@ExperimentalUnsignedTypes

fun UShortArray.slice(indices: Iterable<Int>): List<UShort>

@ExperimentalUnsignedTypes

fun UShortArray.slice(indices: IntRange): List<UShort>

fun <T> List<T>.slice(indices: Iterable<Int>): List<T>

fun <T> List<T>.slice(indices: IntRange): List<T>

sliceArray

fun <T> Array<T>.sliceArray(indices: Collection<Int>): Array<T>

fun <T> Array<T>.sliceArray(indices: IntRange): Array<T>

fun BooleanArray.sliceArray(indices: Collection<Int>): BooleanArray

fun BooleanArray.sliceArray(indices: IntRange): BooleanArray

fun ByteArray.sliceArray(indices: Collection<Int>): ByteArray

fun ByteArray.sliceArray(indices: IntRange): ByteArray

fun CharArray.sliceArray(indices: Collection<Int>): CharArray

fun CharArray.sliceArray(indices: IntRange): CharArray

fun DoubleArray.sliceArray(indices: Collection<Int>): DoubleArray

fun DoubleArray.sliceArray(indices: IntRange): DoubleArray

fun FloatArray.sliceArray(indices: Collection<Int>): FloatArray

fun FloatArray.sliceArray(indices: IntRange): FloatArray

fun IntArray.sliceArray(indices: Collection<Int>): IntArray

fun IntArray.sliceArray(indices: IntRange): IntArray

fun LongArray.sliceArray(indices: Collection<Int>): LongArray

fun LongArray.sliceArray(indices: IntRange): LongArray

fun ShortArray.sliceArray(indices: Collection<Int>): ShortArray

fun ShortArray.sliceArray(indices: IntRange): ShortArray

@ExperimentalUnsignedTypes

fun UByteArray.sliceArray(indices: Collection<Int>): UByteArray

@ExperimentalUnsignedTypes

fun UByteArray.sliceArray(indices: IntRange): UByteArray

@ExperimentalUnsignedTypes

fun UIntArray.sliceArray(indices: Collection<Int>): UIntArray

@ExperimentalUnsignedTypes

fun UIntArray.sliceArray(indices: IntRange): UIntArray

@ExperimentalUnsignedTypes

fun ULongArray.sliceArray(indices: Collection<Int>): ULongArray

@ExperimentalUnsignedTypes

fun ULongArray.sliceArray(indices: IntRange): ULongArray

@ExperimentalUnsignedTypes

fun UShortArray.sliceArray(indices: Collection<Int>): UShortArray

@ExperimentalUnsignedTypes

fun UShortArray.sliceArray(indices: IntRange): UShortArray

sort

fun <T : Comparable<T>> Array<out T>.sort()

fun ByteArray.sort()

fun CharArray.sort()

fun DoubleArray.sort()

fun FloatArray.sort()

fun IntArray.sort()

fun LongArray.sort()

fun ShortArray.sort()

@ExperimentalUnsignedTypes

fun UByteArray.sort()

@ExperimentalUnsignedTypes

fun UIntArray.sort()

@ExperimentalUnsignedTypes

fun ULongArray.sort()

@ExperimentalUnsignedTypes

fun UShortArray.sort()

fun <T : Comparable<T>> MutableList<T>.sort()

@DeprecatedSinceKotlin(warningSince = "1.6")

~~fun~~ <T> Array<out T>.~~sort~~(comparison: (a: T, b: T) -> Int)

fun <T : Comparable<T>> Array<out T>.sort(fromIndex: Int)

@DeprecatedSinceKotlin(warningSince = "1.6")

~~inline~~ ~~fun~~ ByteArray.~~sort~~(noinline comparison: (a: Byte, b: Byte) -> Int)

fun ByteArray.sort(fromIndex: Int)

@DeprecatedSinceKotlin(warningSince = "1.6")

~~inline~~ ~~fun~~ CharArray.~~sort~~(noinline comparison: (a: Char, b: Char) -> Int)

fun CharArray.sort(fromIndex: Int)

@DeprecatedSinceKotlin(warningSince = "1.6")

~~inline~~ ~~fun~~ DoubleArray.~~sort~~(noinline comparison: (a: Double, b: Double) -> Int)

fun DoubleArray.sort(fromIndex: Int)

@DeprecatedSinceKotlin(warningSince = "1.6")

~~inline~~ ~~fun~~ FloatArray.~~sort~~(noinline comparison: (a: Float, b: Float) -> Int)

fun FloatArray.sort(fromIndex: Int)

@DeprecatedSinceKotlin(warningSince = "1.6")

~~inline~~ ~~fun~~ IntArray.~~sort~~(noinline comparison: (a: Int, b: Int) -> Int)

fun IntArray.sort(fromIndex: Int)

@DeprecatedSinceKotlin(warningSince = "1.6")

~~inline~~ ~~fun~~ LongArray.~~sort~~(noinline comparison: (a: Long, b: Long) -> Int)

fun LongArray.sort(fromIndex: Int)

@DeprecatedSinceKotlin(warningSince = "1.6")

~~inline~~ ~~fun~~ ShortArray.~~sort~~(noinline comparison: (a: Short, b: Short) -> Int)

fun ShortArray.sort(fromIndex: Int)

@ExperimentalUnsignedTypes

fun UByteArray.sort(fromIndex: Int)

@ExperimentalUnsignedTypes

fun UIntArray.sort(fromIndex: Int)

@ExperimentalUnsignedTypes

fun ULongArray.sort(fromIndex: Int)

@ExperimentalUnsignedTypes

fun UShortArray.sort(fromIndex: Int)

sortBy

inline fun <T, R : Comparable<R>> Array<out T>.sortBy(crossinline selector: (T) -> R?)

inline fun <T, R : Comparable<R>> MutableList<T>.sortBy(crossinline selector: (T) -> R?)

sortByDescending

inline fun <T, R : Comparable<R>> Array<out T>.sortByDescending(crossinline selector: (T) -> R?)

inline fun <T, R : Comparable<R>> MutableList<T>.sortByDescending(crossinline selector: (T) -> R?)

sortDescending

fun <T : Comparable<T>> Array<out T>.sortDescending()

fun ByteArray.sortDescending()

fun CharArray.sortDescending()

fun DoubleArray.sortDescending()

fun FloatArray.sortDescending()

fun IntArray.sortDescending()

fun LongArray.sortDescending()

fun ShortArray.sortDescending()

@ExperimentalUnsignedTypes

fun UByteArray.sortDescending()

@ExperimentalUnsignedTypes

fun UIntArray.sortDescending()

@ExperimentalUnsignedTypes

fun ULongArray.sortDescending()

@ExperimentalUnsignedTypes

fun UShortArray.sortDescending()

fun <T : Comparable<T>> MutableList<T>.sortDescending()

fun <T : Comparable<T>> Array<out T>.sortDescending(fromIndex: Int, toIndex: Int)

fun ByteArray.sortDescending(fromIndex: Int, toIndex: Int)

fun CharArray.sortDescending(fromIndex: Int, toIndex: Int)

fun DoubleArray.sortDescending(fromIndex: Int, toIndex: Int)

fun FloatArray.sortDescending(fromIndex: Int, toIndex: Int)

fun IntArray.sortDescending(fromIndex: Int, toIndex: Int)

fun LongArray.sortDescending(fromIndex: Int, toIndex: Int)

fun ShortArray.sortDescending(fromIndex: Int, toIndex: Int)

@ExperimentalUnsignedTypes

fun UByteArray.sortDescending(fromIndex: Int, toIndex: Int)

@ExperimentalUnsignedTypes

fun UIntArray.sortDescending(fromIndex: Int, toIndex: Int)

@ExperimentalUnsignedTypes

fun ULongArray.sortDescending(fromIndex: Int, toIndex: Int)

@ExperimentalUnsignedTypes

fun UShortArray.sortDescending(fromIndex: Int, toIndex: Int)

sorted

fun <T : Comparable<T>> Array<out T>.sorted(): List<T>

fun ByteArray.sorted(): List<Byte>

fun CharArray.sorted(): List<Char>

fun DoubleArray.sorted(): List<Double>

fun FloatArray.sorted(): List<Float>

fun IntArray.sorted(): List<Int>

fun LongArray.sorted(): List<Long>

fun ShortArray.sorted(): List<Short>

@ExperimentalUnsignedTypes

fun UByteArray.sorted(): List<UByte>

@ExperimentalUnsignedTypes

fun UIntArray.sorted(): List<UInt>

@ExperimentalUnsignedTypes

fun ULongArray.sorted(): List<ULong>

@ExperimentalUnsignedTypes

fun UShortArray.sorted(): List<UShort>

fun <T : Comparable<T>> Iterable<T>.sorted(): List<T>

sortedArray

fun <T : Comparable<T>> Array<T>.sortedArray(): Array<T>

fun ByteArray.sortedArray(): ByteArray

fun CharArray.sortedArray(): CharArray

fun DoubleArray.sortedArray(): DoubleArray

fun FloatArray.sortedArray(): FloatArray

fun IntArray.sortedArray(): IntArray

fun LongArray.sortedArray(): LongArray

fun ShortArray.sortedArray(): ShortArray

@ExperimentalUnsignedTypes

fun UByteArray.sortedArray(): UByteArray

@ExperimentalUnsignedTypes

fun UIntArray.sortedArray(): UIntArray

@ExperimentalUnsignedTypes

fun ULongArray.sortedArray(): ULongArray

@ExperimentalUnsignedTypes

fun UShortArray.sortedArray(): UShortArray

sortedArrayDescending

fun <T : Comparable<T>> Array<T>.sortedArrayDescending(): Array<T>

fun ByteArray.sortedArrayDescending(): ByteArray

fun CharArray.sortedArrayDescending(): CharArray

fun DoubleArray.sortedArrayDescending(): DoubleArray

fun FloatArray.sortedArrayDescending(): FloatArray

fun IntArray.sortedArrayDescending(): IntArray

fun LongArray.sortedArrayDescending(): LongArray

fun ShortArray.sortedArrayDescending(): ShortArray

@ExperimentalUnsignedTypes

fun UByteArray.sortedArrayDescending(): UByteArray

@ExperimentalUnsignedTypes

fun UIntArray.sortedArrayDescending(): UIntArray

@ExperimentalUnsignedTypes

fun ULongArray.sortedArrayDescending(): ULongArray

@ExperimentalUnsignedTypes

fun UShortArray.sortedArrayDescending(): UShortArray

sortedArrayWith

fun <T> Array<out T>.sortedArrayWith(comparator: Comparator<in T>): Array<out T>

sortedBy

inline fun <T, R : Comparable<R>> Array<out T>.sortedBy(crossinline selector: (T) -> R?): List<T>

inline fun <R : Comparable<R>> BooleanArray.sortedBy(crossinline selector: (Boolean) -> R?): List<Boolean>

inline fun <R : Comparable<R>> ByteArray.sortedBy(crossinline selector: (Byte) -> R?): List<Byte>

inline fun <R : Comparable<R>> CharArray.sortedBy(crossinline selector: (Char) -> R?): List<Char>

inline fun <R : Comparable<R>> DoubleArray.sortedBy(crossinline selector: (Double) -> R?): List<Double>

inline fun <R : Comparable<R>> FloatArray.sortedBy(crossinline selector: (Float) -> R?): List<Float>

inline fun <R : Comparable<R>> IntArray.sortedBy(crossinline selector: (Int) -> R?): List<Int>

inline fun <R : Comparable<R>> LongArray.sortedBy(crossinline selector: (Long) -> R?): List<Long>

inline fun <R : Comparable<R>> ShortArray.sortedBy(crossinline selector: (Short) -> R?): List<Short>

inline fun <T, R : Comparable<R>> Iterable<T>.sortedBy(crossinline selector: (T) -> R?): List<T>

sortedByDescending

inline fun <T, R : Comparable<R>> Array<out T>.sortedByDescending(crossinline selector: (T) -> R?): List<T>

inline fun <R : Comparable<R>> BooleanArray.sortedByDescending(crossinline selector: (Boolean) -> R?): List<Boolean>

inline fun <R : Comparable<R>> ByteArray.sortedByDescending(crossinline selector: (Byte) -> R?): List<Byte>

inline fun <R : Comparable<R>> CharArray.sortedByDescending(crossinline selector: (Char) -> R?): List<Char>

inline fun <R : Comparable<R>> DoubleArray.sortedByDescending(crossinline selector: (Double) -> R?): List<Double>

inline fun <R : Comparable<R>> FloatArray.sortedByDescending(crossinline selector: (Float) -> R?): List<Float>

inline fun <R : Comparable<R>> IntArray.sortedByDescending(crossinline selector: (Int) -> R?): List<Int>

inline fun <R : Comparable<R>> LongArray.sortedByDescending(crossinline selector: (Long) -> R?): List<Long>

inline fun <R : Comparable<R>> ShortArray.sortedByDescending(crossinline selector: (Short) -> R?): List<Short>

inline fun <T, R : Comparable<R>> Iterable<T>.sortedByDescending(crossinline selector: (T) -> R?): List<T>

sortedDescending

fun <T : Comparable<T>> Array<out T>.sortedDescending(): List<T>

fun ByteArray.sortedDescending(): List<Byte>

fun CharArray.sortedDescending(): List<Char>

fun DoubleArray.sortedDescending(): List<Double>

fun FloatArray.sortedDescending(): List<Float>

fun IntArray.sortedDescending(): List<Int>

fun LongArray.sortedDescending(): List<Long>

fun ShortArray.sortedDescending(): List<Short>

@ExperimentalUnsignedTypes

fun UByteArray.sortedDescending(): List<UByte>

@ExperimentalUnsignedTypes

fun UIntArray.sortedDescending(): List<UInt>

@ExperimentalUnsignedTypes

fun ULongArray.sortedDescending(): List<ULong>

@ExperimentalUnsignedTypes

fun UShortArray.sortedDescending(): List<UShort>

fun <T : Comparable<T>> Iterable<T>.sortedDescending(): List<T>

sortedWith

fun <T> Array<out T>.sortedWith(comparator: Comparator<in T>): List<T>

fun BooleanArray.sortedWith(comparator: Comparator<in Boolean>): List<Boolean>

fun ByteArray.sortedWith(comparator: Comparator<in Byte>): List<Byte>

fun CharArray.sortedWith(comparator: Comparator<in Char>): List<Char>

fun DoubleArray.sortedWith(comparator: Comparator<in Double>): List<Double>

fun FloatArray.sortedWith(comparator: Comparator<in Float>): List<Float>

fun IntArray.sortedWith(comparator: Comparator<in Int>): List<Int>

fun LongArray.sortedWith(comparator: Comparator<in Long>): List<Long>

fun ShortArray.sortedWith(comparator: Comparator<in Short>): List<Short>

fun <T> Iterable<T>.sortedWith(comparator: Comparator<in T>): List<T>

sortWith

fun <T> Array<out T>.sortWith(comparator: Comparator<in T>)

fun <T> MutableList<T>.sortWith(comparator: Comparator<in T>)

fun <T> Array<out T>.sortWith(comparator: Comparator<in T>, fromIndex: Int)

stringMapOf

fun <V> stringMapOf(vararg pairs: Pair<String, V>): HashMap<String, V>

stringSetOf

fun stringSetOf(vararg elements: String): HashSet<String>

subtract

infix fun <T> Array<out T>.subtract(other: Iterable<T>): Set<T>

infix fun BooleanArray.subtract(other: Iterable<Boolean>): Set<Boolean>

infix fun ByteArray.subtract(other: Iterable<Byte>): Set<Byte>

infix fun CharArray.subtract(other: Iterable<Char>): Set<Char>

infix fun DoubleArray.subtract(other: Iterable<Double>): Set<Double>

infix fun FloatArray.subtract(other: Iterable<Float>): Set<Float>

infix fun IntArray.subtract(other: Iterable<Int>): Set<Int>

infix fun LongArray.subtract(other: Iterable<Long>): Set<Long>

infix fun ShortArray.subtract(other: Iterable<Short>): Set<Short>

infix fun <T> Iterable<T>.subtract(other: Iterable<T>): Set<T>

sum

@JvmName(name = "sumOfByte")

fun ByteArray.sum(): Int

@JvmName(name = "sumOfDouble")

fun DoubleArray.sum(): Double

@JvmName(name = "sumOfFloat")

fun FloatArray.sum(): Float

@JvmName(name = "sumOfInt")

fun IntArray.sum(): Int

@JvmName(name = "sumOfLong")

fun LongArray.sum(): Long

@JvmName(name = "sumOfShort")

fun ShortArray.sum(): Int

@JvmName(name = "sumOfUByte")

fun Array<out UByte>.sum(): UInt

@JvmName(name = "sumOfUInt")

fun Array<out UInt>.sum(): UInt

@JvmName(name = "sumOfULong")

fun Array<out ULong>.sum(): ULong

@JvmName(name = "sumOfUShort")

fun Array<out UShort>.sum(): UInt

fun ByteArray.sum(): Int

fun DoubleArray.sum(): Double

fun FloatArray.sum(): Float

fun IntArray.sum(): Int

fun LongArray.sum(): Long

fun ShortArray.sum(): Int

@ExperimentalUnsignedTypes

inline fun UByteArray.sum(): UInt

@ExperimentalUnsignedTypes

inline fun UIntArray.sum(): UInt

@ExperimentalUnsignedTypes

inline fun ULongArray.sum(): ULong

@ExperimentalUnsignedTypes

inline fun UShortArray.sum(): UInt

@JvmName(name = "sumOfByte")

fun Iterable<Byte>.sum(): Int

@JvmName(name = "sumOfDouble")

fun Iterable<Double>.sum(): Double

@JvmName(name = "sumOfFloat")

fun Iterable<Float>.sum(): Float

@JvmName(name = "sumOfInt")

fun Iterable<Int>.sum(): Int

@JvmName(name = "sumOfLong")

fun Iterable<Long>.sum(): Long

@JvmName(name = "sumOfShort")

fun Iterable<Short>.sum(): Int

@JvmName(name = "sumOfUByte")

fun Iterable<UByte>.sum(): UInt

@JvmName(name = "sumOfUInt")

fun Iterable<UInt>.sum(): UInt

@JvmName(name = "sumOfULong")

fun Iterable<ULong>.sum(): ULong

@JvmName(name = "sumOfUShort")

fun Iterable<UShort>.sum(): UInt

sumBy

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ <T> Array<out T>.~~sumBy~~(selector: (T) -> Int): Int

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ BooleanArray.~~sumBy~~(selector: (Boolean) -> Int): Int

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ ByteArray.~~sumBy~~(selector: (Byte) -> Int): Int

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ CharArray.~~sumBy~~(selector: (Char) -> Int): Int

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ DoubleArray.~~sumBy~~(selector: (Double) -> Int): Int

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ FloatArray.~~sumBy~~(selector: (Float) -> Int): Int

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ IntArray.~~sumBy~~(selector: (Int) -> Int): Int

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ LongArray.~~sumBy~~(selector: (Long) -> Int): Int

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ ShortArray.~~sumBy~~(selector: (Short) -> Int): Int

@DeprecatedSinceKotlin(warningSince = "1.5")

@ExperimentalUnsignedTypes

~~inline~~ ~~fun~~ UByteArray.~~sumBy~~(selector: (UByte) -> UInt): UInt

@DeprecatedSinceKotlin(warningSince = "1.5")

@ExperimentalUnsignedTypes

~~inline~~ ~~fun~~ UIntArray.~~sumBy~~(selector: (UInt) -> UInt): UInt

@DeprecatedSinceKotlin(warningSince = "1.5")

@ExperimentalUnsignedTypes

~~inline~~ ~~fun~~ ULongArray.~~sumBy~~(selector: (ULong) -> UInt): UInt

@DeprecatedSinceKotlin(warningSince = "1.5")

@ExperimentalUnsignedTypes

~~inline~~ ~~fun~~ UShortArray.~~sumBy~~(selector: (UShort) -> UInt): UInt

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ <T> Iterable<T>.~~sumBy~~(selector: (T) -> Int): Int

sumByDouble

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ <T> Array<out T>.~~sumByDouble~~(selector: (T) -> Double): Double

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ BooleanArray.~~sumByDouble~~(selector: (Boolean) -> Double): Double

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ ByteArray.~~sumByDouble~~(selector: (Byte) -> Double): Double

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ CharArray.~~sumByDouble~~(selector: (Char) -> Double): Double

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ DoubleArray.~~sumByDouble~~(selector: (Double) -> Double): Double

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ FloatArray.~~sumByDouble~~(selector: (Float) -> Double): Double

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ IntArray.~~sumByDouble~~(selector: (Int) -> Double): Double

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ LongArray.~~sumByDouble~~(selector: (Long) -> Double): Double

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ ShortArray.~~sumByDouble~~(selector: (Short) -> Double): Double

@DeprecatedSinceKotlin(warningSince = "1.5")

@ExperimentalUnsignedTypes

~~inline~~ ~~fun~~ UByteArray.~~sumByDouble~~(selector: (UByte) -> Double): Double

@DeprecatedSinceKotlin(warningSince = "1.5")

@ExperimentalUnsignedTypes

~~inline~~ ~~fun~~ UIntArray.~~sumByDouble~~(selector: (UInt) -> Double): Double

@DeprecatedSinceKotlin(warningSince = "1.5")

@ExperimentalUnsignedTypes

~~inline~~ ~~fun~~ ULongArray.~~sumByDouble~~(selector: (ULong) -> Double): Double

@DeprecatedSinceKotlin(warningSince = "1.5")

@ExperimentalUnsignedTypes

~~inline~~ ~~fun~~ UShortArray.~~sumByDouble~~(selector: (UShort) -> Double): Double

@DeprecatedSinceKotlin(warningSince = "1.5")

~~inline~~ ~~fun~~ <T> Iterable<T>.~~sumByDouble~~(selector: (T) -> Double): Double

sumOf

@JvmName(name = "sumOfDouble")

inline fun <T> Array<out T>.sumOf(selector: (T) -> Double): Double

@JvmName(name = "sumOfInt")

inline fun <T> Array<out T>.sumOf(selector: (T) -> Int): Int

@JvmName(name = "sumOfLong")

inline fun <T> Array<out T>.sumOf(selector: (T) -> Long): Long

@JvmName(name = "sumOfUInt")

inline fun <T> Array<out T>.sumOf(selector: (T) -> UInt): UInt

@JvmName(name = "sumOfULong")

inline fun <T> Array<out T>.sumOf(selector: (T) -> ULong): ULong

@JvmName(name = "sumOfDouble")

inline fun BooleanArray.sumOf(selector: (Boolean) -> Double): Double

@JvmName(name = "sumOfInt")

inline fun BooleanArray.sumOf(selector: (Boolean) -> Int): Int

@JvmName(name = "sumOfLong")

inline fun BooleanArray.sumOf(selector: (Boolean) -> Long): Long

@JvmName(name = "sumOfUInt")

inline fun BooleanArray.sumOf(selector: (Boolean) -> UInt): UInt

@JvmName(name = "sumOfULong")

inline fun BooleanArray.sumOf(selector: (Boolean) -> ULong): ULong

@JvmName(name = "sumOfDouble")

inline fun ByteArray.sumOf(selector: (Byte) -> Double): Double

@JvmName(name = "sumOfInt")

inline fun ByteArray.sumOf(selector: (Byte) -> Int): Int

@JvmName(name = "sumOfLong")

inline fun ByteArray.sumOf(selector: (Byte) -> Long): Long

@JvmName(name = "sumOfUInt")

inline fun ByteArray.sumOf(selector: (Byte) -> UInt): UInt

@JvmName(name = "sumOfULong")

inline fun ByteArray.sumOf(selector: (Byte) -> ULong): ULong

@JvmName(name = "sumOfDouble")

inline fun CharArray.sumOf(selector: (Char) -> Double): Double

@JvmName(name = "sumOfInt")

inline fun CharArray.sumOf(selector: (Char) -> Int): Int

@JvmName(name = "sumOfLong")

inline fun CharArray.sumOf(selector: (Char) -> Long): Long

@JvmName(name = "sumOfUInt")

inline fun CharArray.sumOf(selector: (Char) -> UInt): UInt

@JvmName(name = "sumOfULong")

inline fun CharArray.sumOf(selector: (Char) -> ULong): ULong

@JvmName(name = "sumOfDouble")

inline fun DoubleArray.sumOf(selector: (Double) -> Double): Double

@JvmName(name = "sumOfInt")

inline fun DoubleArray.sumOf(selector: (Double) -> Int): Int

@JvmName(name = "sumOfLong")

inline fun DoubleArray.sumOf(selector: (Double) -> Long): Long

@JvmName(name = "sumOfUInt")

inline fun DoubleArray.sumOf(selector: (Double) -> UInt): UInt

@JvmName(name = "sumOfULong")

inline fun DoubleArray.sumOf(selector: (Double) -> ULong): ULong

@JvmName(name = "sumOfDouble")

inline fun FloatArray.sumOf(selector: (Float) -> Double): Double

@JvmName(name = "sumOfInt")

inline fun FloatArray.sumOf(selector: (Float) -> Int): Int

@JvmName(name = "sumOfLong")

inline fun FloatArray.sumOf(selector: (Float) -> Long): Long

@JvmName(name = "sumOfUInt")

inline fun FloatArray.sumOf(selector: (Float) -> UInt): UInt

@JvmName(name = "sumOfULong")

inline fun FloatArray.sumOf(selector: (Float) -> ULong): ULong

@JvmName(name = "sumOfDouble")

inline fun IntArray.sumOf(selector: (Int) -> Double): Double

@JvmName(name = "sumOfInt")

inline fun IntArray.sumOf(selector: (Int) -> Int): Int

@JvmName(name = "sumOfLong")

inline fun IntArray.sumOf(selector: (Int) -> Long): Long

@JvmName(name = "sumOfUInt")

inline fun IntArray.sumOf(selector: (Int) -> UInt): UInt

@JvmName(name = "sumOfULong")

inline fun IntArray.sumOf(selector: (Int) -> ULong): ULong

@JvmName(name = "sumOfDouble")

inline fun LongArray.sumOf(selector: (Long) -> Double): Double

@JvmName(name = "sumOfInt")

inline fun LongArray.sumOf(selector: (Long) -> Int): Int

@JvmName(name = "sumOfLong")

inline fun LongArray.sumOf(selector: (Long) -> Long): Long

@JvmName(name = "sumOfUInt")

inline fun LongArray.sumOf(selector: (Long) -> UInt): UInt

@JvmName(name = "sumOfULong")

inline fun LongArray.sumOf(selector: (Long) -> ULong): ULong

@JvmName(name = "sumOfDouble")

inline fun ShortArray.sumOf(selector: (Short) -> Double): Double

@JvmName(name = "sumOfInt")

inline fun ShortArray.sumOf(selector: (Short) -> Int): Int

@JvmName(name = "sumOfLong")

inline fun ShortArray.sumOf(selector: (Short) -> Long): Long

@JvmName(name = "sumOfUInt")

inline fun ShortArray.sumOf(selector: (Short) -> UInt): UInt

@JvmName(name = "sumOfULong")

inline fun ShortArray.sumOf(selector: (Short) -> ULong): ULong

@JvmName(name = "sumOfDouble")

@ExperimentalUnsignedTypes

inline fun UByteArray.sumOf(selector: (UByte) -> Double): Double

@JvmName(name = "sumOfInt")

@ExperimentalUnsignedTypes

inline fun UByteArray.sumOf(selector: (UByte) -> Int): Int

@JvmName(name = "sumOfLong")

@ExperimentalUnsignedTypes

inline fun UByteArray.sumOf(selector: (UByte) -> Long): Long

@JvmName(name = "sumOfUInt")

@ExperimentalUnsignedTypes

inline fun UByteArray.sumOf(selector: (UByte) -> UInt): UInt

@JvmName(name = "sumOfULong")

@ExperimentalUnsignedTypes

inline fun UByteArray.sumOf(selector: (UByte) -> ULong): ULong

@JvmName(name = "sumOfDouble")

@ExperimentalUnsignedTypes

inline fun UIntArray.sumOf(selector: (UInt) -> Double): Double

@JvmName(name = "sumOfInt")

@ExperimentalUnsignedTypes

inline fun UIntArray.sumOf(selector: (UInt) -> Int): Int

@JvmName(name = "sumOfLong")

@ExperimentalUnsignedTypes

inline fun UIntArray.sumOf(selector: (UInt) -> Long): Long

@JvmName(name = "sumOfUInt")

@ExperimentalUnsignedTypes

inline fun UIntArray.sumOf(selector: (UInt) -> UInt): UInt

@JvmName(name = "sumOfULong")

@ExperimentalUnsignedTypes

inline fun UIntArray.sumOf(selector: (UInt) -> ULong): ULong

@JvmName(name = "sumOfDouble")

@ExperimentalUnsignedTypes

inline fun ULongArray.sumOf(selector: (ULong) -> Double): Double

@JvmName(name = "sumOfInt")

@ExperimentalUnsignedTypes

inline fun ULongArray.sumOf(selector: (ULong) -> Int): Int

@JvmName(name = "sumOfLong")

@ExperimentalUnsignedTypes

inline fun ULongArray.sumOf(selector: (ULong) -> Long): Long

@JvmName(name = "sumOfUInt")

@ExperimentalUnsignedTypes

inline fun ULongArray.sumOf(selector: (ULong) -> UInt): UInt

@JvmName(name = "sumOfULong")

@ExperimentalUnsignedTypes

inline fun ULongArray.sumOf(selector: (ULong) -> ULong): ULong

@JvmName(name = "sumOfDouble")

@ExperimentalUnsignedTypes

inline fun UShortArray.sumOf(selector: (UShort) -> Double): Double

@JvmName(name = "sumOfInt")

@ExperimentalUnsignedTypes

inline fun UShortArray.sumOf(selector: (UShort) -> Int): Int

@JvmName(name = "sumOfLong")

@ExperimentalUnsignedTypes

inline fun UShortArray.sumOf(selector: (UShort) -> Long): Long

@JvmName(name = "sumOfUInt")

@ExperimentalUnsignedTypes

inline fun UShortArray.sumOf(selector: (UShort) -> UInt): UInt

@JvmName(name = "sumOfULong")

@ExperimentalUnsignedTypes

inline fun UShortArray.sumOf(selector: (UShort) -> ULong): ULong

@JvmName(name = "sumOfDouble")

inline fun <T> Iterable<T>.sumOf(selector: (T) -> Double): Double

@JvmName(name = "sumOfInt")

inline fun <T> Iterable<T>.sumOf(selector: (T) -> Int): Int

@JvmName(name = "sumOfLong")

inline fun <T> Iterable<T>.sumOf(selector: (T) -> Long): Long

@JvmName(name = "sumOfUInt")

inline fun <T> Iterable<T>.sumOf(selector: (T) -> UInt): UInt

@JvmName(name = "sumOfULong")

inline fun <T> Iterable<T>.sumOf(selector: (T) -> ULong): ULong

take

fun <T> Array<out T>.take(n: Int): List<T>

fun BooleanArray.take(n: Int): List<Boolean>

fun ByteArray.take(n: Int): List<Byte>

fun CharArray.take(n: Int): List<Char>

fun DoubleArray.take(n: Int): List<Double>

fun FloatArray.take(n: Int): List<Float>

fun IntArray.take(n: Int): List<Int>

fun LongArray.take(n: Int): List<Long>

fun ShortArray.take(n: Int): List<Short>

@ExperimentalUnsignedTypes

fun UByteArray.take(n: Int): List<UByte>

@ExperimentalUnsignedTypes

fun UIntArray.take(n: Int): List<UInt>

@ExperimentalUnsignedTypes

fun ULongArray.take(n: Int): List<ULong>

@ExperimentalUnsignedTypes

fun UShortArray.take(n: Int): List<UShort>

fun <T> Iterable<T>.take(n: Int): List<T>

takeLast

fun <T> Array<out T>.takeLast(n: Int): List<T>

fun BooleanArray.takeLast(n: Int): List<Boolean>

fun ByteArray.takeLast(n: Int): List<Byte>

fun CharArray.takeLast(n: Int): List<Char>

fun DoubleArray.takeLast(n: Int): List<Double>

fun FloatArray.takeLast(n: Int): List<Float>

fun IntArray.takeLast(n: Int): List<Int>

fun LongArray.takeLast(n: Int): List<Long>

fun ShortArray.takeLast(n: Int): List<Short>

@ExperimentalUnsignedTypes

fun UByteArray.takeLast(n: Int): List<UByte>

@ExperimentalUnsignedTypes

fun UIntArray.takeLast(n: Int): List<UInt>

@ExperimentalUnsignedTypes

fun ULongArray.takeLast(n: Int): List<ULong>

@ExperimentalUnsignedTypes

fun UShortArray.takeLast(n: Int): List<UShort>

fun <T> List<T>.takeLast(n: Int): List<T>

takeLastWhile

inline fun <T> Array<out T>.takeLastWhile(predicate: (T) -> Boolean): List<T>

inline fun BooleanArray.takeLastWhile(predicate: (Boolean) -> Boolean): List<Boolean>

inline fun ByteArray.takeLastWhile(predicate: (Byte) -> Boolean): List<Byte>

inline fun CharArray.takeLastWhile(predicate: (Char) -> Boolean): List<Char>

inline fun DoubleArray.takeLastWhile(predicate: (Double) -> Boolean): List<Double>

inline fun FloatArray.takeLastWhile(predicate: (Float) -> Boolean): List<Float>

inline fun IntArray.takeLastWhile(predicate: (Int) -> Boolean): List<Int>

inline fun LongArray.takeLastWhile(predicate: (Long) -> Boolean): List<Long>

inline fun ShortArray.takeLastWhile(predicate: (Short) -> Boolean): List<Short>

@ExperimentalUnsignedTypes

inline fun UByteArray.takeLastWhile(predicate: (UByte) -> Boolean): List<UByte>

@ExperimentalUnsignedTypes

inline fun UIntArray.takeLastWhile(predicate: (UInt) -> Boolean): List<UInt>

@ExperimentalUnsignedTypes

inline fun ULongArray.takeLastWhile(predicate: (ULong) -> Boolean): List<ULong>

@ExperimentalUnsignedTypes

inline fun UShortArray.takeLastWhile(predicate: (UShort) -> Boolean): List<UShort>

inline fun <T> List<T>.takeLastWhile(predicate: (T) -> Boolean): List<T>

takeWhile

inline fun <T> Array<out T>.takeWhile(predicate: (T) -> Boolean): List<T>

inline fun BooleanArray.takeWhile(predicate: (Boolean) -> Boolean): List<Boolean>

inline fun ByteArray.takeWhile(predicate: (Byte) -> Boolean): List<Byte>

inline fun CharArray.takeWhile(predicate: (Char) -> Boolean): List<Char>

inline fun DoubleArray.takeWhile(predicate: (Double) -> Boolean): List<Double>

inline fun FloatArray.takeWhile(predicate: (Float) -> Boolean): List<Float>

inline fun IntArray.takeWhile(predicate: (Int) -> Boolean): List<Int>

inline fun LongArray.takeWhile(predicate: (Long) -> Boolean): List<Long>

inline fun ShortArray.takeWhile(predicate: (Short) -> Boolean): List<Short>

@ExperimentalUnsignedTypes

inline fun UByteArray.takeWhile(predicate: (UByte) -> Boolean): List<UByte>

@ExperimentalUnsignedTypes

inline fun UIntArray.takeWhile(predicate: (UInt) -> Boolean): List<UInt>

@ExperimentalUnsignedTypes

inline fun ULongArray.takeWhile(predicate: (ULong) -> Boolean): List<ULong>

@ExperimentalUnsignedTypes

inline fun UShortArray.takeWhile(predicate: (UShort) -> Boolean): List<UShort>

inline fun <T> Iterable<T>.takeWhile(predicate: (T) -> Boolean): List<T>

toBooleanArray

fun BooleanArray.toBooleanArray(): BooleanArray

fun Collection<Boolean>.toBooleanArray(): BooleanArray

toByteArray

fun ByteArray.toByteArray(): ByteArray

@ExperimentalUnsignedTypes

inline fun UByteArray.toByteArray(): ByteArray

fun Collection<Byte>.toByteArray(): ByteArray

toCharArray

fun CharArray.toCharArray(): CharArray

fun Collection<Char>.toCharArray(): CharArray

toCollection

fun <T, C : MutableCollection<in T>> Array<out T>.toCollection(destination: C): C

fun <C : MutableCollection<in Boolean>> BooleanArray.toCollection(destination: C): C

fun <C : MutableCollection<in Byte>> ByteArray.toCollection(destination: C): C

fun <C : MutableCollection<in Char>> CharArray.toCollection(destination: C): C

fun <C : MutableCollection<in Double>> DoubleArray.toCollection(destination: C): C

fun <C : MutableCollection<in Float>> FloatArray.toCollection(destination: C): C

fun <C : MutableCollection<in Int>> IntArray.toCollection(destination: C): C

fun <C : MutableCollection<in Long>> LongArray.toCollection(destination: C): C

fun <C : MutableCollection<in Short>> ShortArray.toCollection(destination: C): C

fun <T, C : MutableCollection<in T>> Iterable<T>.toCollection(destination: C): C

toDoubleArray

fun DoubleArray.toDoubleArray(): DoubleArray

fun Collection<Double>.toDoubleArray(): DoubleArray

toFloatArray

fun FloatArray.toFloatArray(): FloatArray

fun Collection<Float>.toFloatArray(): FloatArray

toHashSet

fun <T> Array<out T>.toHashSet(): HashSet<T>

fun BooleanArray.toHashSet(): HashSet<Boolean>

fun ByteArray.toHashSet(): HashSet<Byte>

fun CharArray.toHashSet(): HashSet<Char>

fun DoubleArray.toHashSet(): HashSet<Double>

fun FloatArray.toHashSet(): HashSet<Float>

fun IntArray.toHashSet(): HashSet<Int>

fun LongArray.toHashSet(): HashSet<Long>

fun ShortArray.toHashSet(): HashSet<Short>

fun <T> Iterable<T>.toHashSet(): HashSet<T>

toIntArray

fun IntArray.toIntArray(): IntArray

@ExperimentalUnsignedTypes

inline fun UIntArray.toIntArray(): IntArray

fun Collection<Int>.toIntArray(): IntArray

toList

fun <T> Array<out T>.toList(): List<T>

fun BooleanArray.toList(): List<Boolean>

fun ByteArray.toList(): List<Byte>

fun CharArray.toList(): List<Char>

fun DoubleArray.toList(): List<Double>

fun FloatArray.toList(): List<Float>

fun IntArray.toList(): List<Int>

fun LongArray.toList(): List<Long>

fun ShortArray.toList(): List<Short>

fun <T> Iterable<T>.toList(): List<T>

fun <K, V> Map<out K, V>.toList(): List<Pair<K, V>>

toLongArray

fun LongArray.toLongArray(): LongArray

@ExperimentalUnsignedTypes

inline fun ULongArray.toLongArray(): LongArray

fun Collection<Long>.toLongArray(): LongArray

toMap

fun <K, V> Array<out Pair<K, V>>.toMap(): Map<K, V>

fun <K, V> Iterable<Pair<K, V>>.toMap(): Map<K, V>

fun <K, V> Map<out K, V>.toMap(): Map<K, V>

fun <K, V> Sequence<Pair<K, V>>.toMap(): Map<K, V>

fun <K, V, M : MutableMap<in K, in V>> Array<out Pair<K, V>>.toMap(destination: M): M

fun <K, V, M : MutableMap<in K, in V>> Iterable<Pair<K, V>>.toMap(destination: M): M

fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.toMap(destination: M): M

fun <K, V, M : MutableMap<in K, in V>> Sequence<Pair<K, V>>.toMap(destination: M): M

toMutableList

fun <T> Array<out T>.toMutableList(): MutableList<T>

fun BooleanArray.toMutableList(): MutableList<Boolean>

fun ByteArray.toMutableList(): MutableList<Byte>

fun CharArray.toMutableList(): MutableList<Char>

fun DoubleArray.toMutableList(): MutableList<Double>

fun FloatArray.toMutableList(): MutableList<Float>

fun IntArray.toMutableList(): MutableList<Int>

fun LongArray.toMutableList(): MutableList<Long>

fun ShortArray.toMutableList(): MutableList<Short>

fun <T> Collection<T>.toMutableList(): MutableList<T>

fun <T> Iterable<T>.toMutableList(): MutableList<T>

toMutableMap

fun <K, V> Map<out K, V>.toMutableMap(): MutableMap<K, V>

toMutableSet

fun <T> Array<out T>.toMutableSet(): MutableSet<T>

fun BooleanArray.toMutableSet(): MutableSet<Boolean>

fun ByteArray.toMutableSet(): MutableSet<Byte>

fun CharArray.toMutableSet(): MutableSet<Char>

fun DoubleArray.toMutableSet(): MutableSet<Double>

fun FloatArray.toMutableSet(): MutableSet<Float>

fun IntArray.toMutableSet(): MutableSet<Int>

fun LongArray.toMutableSet(): MutableSet<Long>

fun ShortArray.toMutableSet(): MutableSet<Short>

fun <T> Iterable<T>.toMutableSet(): MutableSet<T>

toPair

inline fun <K, V> Map.Entry<K, V>.toPair(): Pair<K, V>

toSet

fun <T> Array<out T>.toSet(): Set<T>

fun BooleanArray.toSet(): Set<Boolean>

fun ByteArray.toSet(): Set<Byte>

fun CharArray.toSet(): Set<Char>

fun DoubleArray.toSet(): Set<Double>

fun FloatArray.toSet(): Set<Float>

fun IntArray.toSet(): Set<Int>

fun LongArray.toSet(): Set<Long>

fun ShortArray.toSet(): Set<Short>

fun <T> Iterable<T>.toSet(): Set<T>

toShortArray

fun ShortArray.toShortArray(): ShortArray

@ExperimentalUnsignedTypes

inline fun UShortArray.toShortArray(): ShortArray

fun Collection<Short>.toShortArray(): ShortArray

toTypedArray

fun BooleanArray.toTypedArray(): BooleanArray

fun ByteArray.toTypedArray(): ByteArray

fun CharArray.toTypedArray(): CharArray

fun DoubleArray.toTypedArray(): DoubleArray

fun FloatArray.toTypedArray(): FloatArray

fun IntArray.toTypedArray(): IntArray

fun LongArray.toTypedArray(): LongArray

fun ShortArray.toTypedArray(): ShortArray

@ExperimentalUnsignedTypes

fun UByteArray.toTypedArray(): Array<UByte>

@ExperimentalUnsignedTypes

fun UIntArray.toTypedArray(): Array<UInt>

@ExperimentalUnsignedTypes

fun ULongArray.toTypedArray(): Array<ULong>

@ExperimentalUnsignedTypes

fun UShortArray.toTypedArray(): Array<UShort>

inline fun <T> Collection<T>.toTypedArray(): Array<T>

toUByteArray

@ExperimentalUnsignedTypes

fun Array<out UByte>.toUByteArray(): UByteArray

@ExperimentalUnsignedTypes

inline fun ByteArray.toUByteArray(): UByteArray

@ExperimentalUnsignedTypes

fun Collection<UByte>.toUByteArray(): UByteArray

toUIntArray

@ExperimentalUnsignedTypes

fun Array<out UInt>.toUIntArray(): UIntArray

@ExperimentalUnsignedTypes

inline fun IntArray.toUIntArray(): UIntArray

@ExperimentalUnsignedTypes

fun Collection<UInt>.toUIntArray(): UIntArray

toULongArray

@ExperimentalUnsignedTypes

fun Array<out ULong>.toULongArray(): ULongArray

@ExperimentalUnsignedTypes

inline fun LongArray.toULongArray(): ULongArray

@ExperimentalUnsignedTypes

fun Collection<ULong>.toULongArray(): ULongArray

toUShortArray

@ExperimentalUnsignedTypes

fun Array<out UShort>.toUShortArray(): UShortArray

@ExperimentalUnsignedTypes

inline fun ShortArray.toUShortArray(): UShortArray

@ExperimentalUnsignedTypes

fun Collection<UShort>.toUShortArray(): UShortArray

union

infix fun <T> Array<out T>.union(other: Iterable<T>): Set<T>

infix fun BooleanArray.union(other: Iterable<Boolean>): Set<Boolean>

infix fun ByteArray.union(other: Iterable<Byte>): Set<Byte>

infix fun CharArray.union(other: Iterable<Char>): Set<Char>

infix fun DoubleArray.union(other: Iterable<Double>): Set<Double>

infix fun FloatArray.union(other: Iterable<Float>): Set<Float>

infix fun IntArray.union(other: Iterable<Int>): Set<Int>

infix fun LongArray.union(other: Iterable<Long>): Set<Long>

infix fun ShortArray.union(other: Iterable<Short>): Set<Short>

infix fun <T> Iterable<T>.union(other: Iterable<T>): Set<T>

unzip

fun <T, R> Array<out Pair<T, R>>.unzip(): Pair<List<T>, List<R>>

fun <T, R> Iterable<Pair<T, R>>.unzip(): Pair<List<T>, List<R>>

windowed

fun <T> Iterable<T>.windowed(size: Int, step: Int)

fun <T, R> Iterable<T>.windowed(size: Int, step: Int)

withDefault

fun <K, V> Map<K, V>.withDefault(defaultValue: (key: K) -> V): Map<K, V>

@JvmName(name = "withDefaultMutable")

fun <K, V> MutableMap<K, V>.withDefault(defaultValue: (key: K) -> V): MutableMap<K, V>

withIndex

fun <T> Array<out T>.withIndex(): Iterable<IndexedValue<T>>

fun BooleanArray.withIndex(): Iterable<IndexedValue<Boolean>>

fun ByteArray.withIndex(): Iterable<IndexedValue<Byte>>

fun CharArray.withIndex(): Iterable<IndexedValue<Char>>

fun DoubleArray.withIndex(): Iterable<IndexedValue<Double>>

fun FloatArray.withIndex(): Iterable<IndexedValue<Float>>

fun IntArray.withIndex(): Iterable<IndexedValue<Int>>

fun LongArray.withIndex(): Iterable<IndexedValue<Long>>

fun ShortArray.withIndex(): Iterable<IndexedValue<Short>>

@ExperimentalUnsignedTypes

fun UByteArray.withIndex(): Iterable<IndexedValue<UByte>>

@ExperimentalUnsignedTypes

fun UIntArray.withIndex(): Iterable<IndexedValue<UInt>>

@ExperimentalUnsignedTypes

fun ULongArray.withIndex(): Iterable<IndexedValue<ULong>>

@ExperimentalUnsignedTypes

fun UShortArray.withIndex(): Iterable<IndexedValue<UShort>>

fun <T> Iterable<T>.withIndex(): Iterable<IndexedValue<T>>

fun <T> Iterator<T>.withIndex(): Iterator<IndexedValue<T>>

zip

infix fun <T, R> Array<out T>.zip(other: Array<out R>): List<Pair<T, R>>

infix fun <T, R> Array<out T>.zip(other: Iterable<R>): List<Pair<T, R>>

infix fun <R> BooleanArray.zip(other: Array<out R>): List<Pair<Boolean, R>>

infix fun BooleanArray.zip(other: BooleanArray): List<Pair<Boolean, Boolean>>

infix fun <R> BooleanArray.zip(other: Iterable<R>): List<Pair<Boolean, R>>

infix fun <R> ByteArray.zip(other: Array<out R>): List<Pair<Byte, R>>

infix fun ByteArray.zip(other: ByteArray): List<Pair<Byte, Byte>>

infix fun <R> ByteArray.zip(other: Iterable<R>): List<Pair<Byte, R>>

infix fun <R> CharArray.zip(other: Array<out R>): List<Pair<Char, R>>

infix fun CharArray.zip(other: CharArray): List<Pair<Char, Char>>

infix fun <R> CharArray.zip(other: Iterable<R>): List<Pair<Char, R>>

infix fun <R> DoubleArray.zip(other: Array<out R>): List<Pair<Double, R>>

infix fun DoubleArray.zip(other: DoubleArray): List<Pair<Double, Double>>

infix fun <R> DoubleArray.zip(other: Iterable<R>): List<Pair<Double, R>>

infix fun <R> FloatArray.zip(other: Array<out R>): List<Pair<Float, R>>

infix fun FloatArray.zip(other: FloatArray): List<Pair<Float, Float>>

infix fun <R> FloatArray.zip(other: Iterable<R>): List<Pair<Float, R>>

infix fun <R> IntArray.zip(other: Array<out R>): List<Pair<Int, R>>

infix fun IntArray.zip(other: IntArray): List<Pair<Int, Int>>

infix fun <R> IntArray.zip(other: Iterable<R>): List<Pair<Int, R>>

infix fun <R> LongArray.zip(other: Array<out R>): List<Pair<Long, R>>

infix fun LongArray.zip(other: LongArray): List<Pair<Long, Long>>

infix fun <R> LongArray.zip(other: Iterable<R>): List<Pair<Long, R>>

infix fun <R> ShortArray.zip(other: Array<out R>): List<Pair<Short, R>>

infix fun ShortArray.zip(other: ShortArray): List<Pair<Short, Short>>

infix fun <R> ShortArray.zip(other: Iterable<R>): List<Pair<Short, R>>

@ExperimentalUnsignedTypes

infix fun <R> UByteArray.zip(other: Array<out R>): List<Pair<UByte, R>>

@ExperimentalUnsignedTypes

infix fun UByteArray.zip(other: UByteArray): List<Pair<UByte, UByte>>

@ExperimentalUnsignedTypes

infix fun <R> UByteArray.zip(other: Iterable<R>): List<Pair<UByte, R>>

@ExperimentalUnsignedTypes

infix fun <R> UIntArray.zip(other: Array<out R>): List<Pair<UInt, R>>

@ExperimentalUnsignedTypes

infix fun UIntArray.zip(other: UIntArray): List<Pair<UInt, UInt>>

@ExperimentalUnsignedTypes

infix fun <R> UIntArray.zip(other: Iterable<R>): List<Pair<UInt, R>>

@ExperimentalUnsignedTypes

infix fun <R> ULongArray.zip(other: Array<out R>): List<Pair<ULong, R>>

@ExperimentalUnsignedTypes

infix fun ULongArray.zip(other: ULongArray): List<Pair<ULong, ULong>>

@ExperimentalUnsignedTypes

infix fun <R> ULongArray.zip(other: Iterable<R>): List<Pair<ULong, R>>

@ExperimentalUnsignedTypes

infix fun <R> UShortArray.zip(other: Array<out R>): List<Pair<UShort, R>>

@ExperimentalUnsignedTypes

infix fun UShortArray.zip(other: UShortArray): List<Pair<UShort, UShort>>

@ExperimentalUnsignedTypes

infix fun <R> UShortArray.zip(other: Iterable<R>): List<Pair<UShort, R>>

infix fun <T, R> Iterable<T>.zip(other: Array<out R>): List<Pair<T, R>>

infix fun <T, R> Iterable<T>.zip(other: Iterable<R>): List<Pair<T, R>>

inline fun <T, R, V> Array<out T>.zip(other: Array<out R>, transform: (a: T, b: R) -> V): List<V>

inline fun <T, R, V> Array<out T>.zip(other: Iterable<R>, transform: (a: T, b: R) -> V): List<V>

inline fun <R, V> BooleanArray.zip(other: Array<out R>, transform: (a: Boolean, b: R) -> V): List<V>

inline fun <V> BooleanArray.zip(other: BooleanArray, transform: (a: Boolean, b: Boolean) -> V): List<V>

inline fun <R, V> BooleanArray.zip(other: Iterable<R>, transform: (a: Boolean, b: R) -> V): List<V>

inline fun <R, V> ByteArray.zip(other: Array<out R>, transform: (a: Byte, b: R) -> V): List<V>

inline fun <V> ByteArray.zip(other: ByteArray, transform: (a: Byte, b: Byte) -> V): List<V>

inline fun <R, V> ByteArray.zip(other: Iterable<R>, transform: (a: Byte, b: R) -> V): List<V>

inline fun <R, V> CharArray.zip(other: Array<out R>, transform: (a: Char, b: R) -> V): List<V>

inline fun <V> CharArray.zip(other: CharArray, transform: (a: Char, b: Char) -> V): List<V>

inline fun <R, V> CharArray.zip(other: Iterable<R>, transform: (a: Char, b: R) -> V): List<V>

inline fun <R, V> DoubleArray.zip(other: Array<out R>, transform: (a: Double, b: R) -> V): List<V>

inline fun <V> DoubleArray.zip(other: DoubleArray, transform: (a: Double, b: Double) -> V): List<V>

inline fun <R, V> DoubleArray.zip(other: Iterable<R>, transform: (a: Double, b: R) -> V): List<V>

inline fun <R, V> FloatArray.zip(other: Array<out R>, transform: (a: Float, b: R) -> V): List<V>

inline fun <V> FloatArray.zip(other: FloatArray, transform: (a: Float, b: Float) -> V): List<V>

inline fun <R, V> FloatArray.zip(other: Iterable<R>, transform: (a: Float, b: R) -> V): List<V>

inline fun <R, V> IntArray.zip(other: Array<out R>, transform: (a: Int, b: R) -> V): List<V>

inline fun <V> IntArray.zip(other: IntArray, transform: (a: Int, b: Int) -> V): List<V>

inline fun <R, V> IntArray.zip(other: Iterable<R>, transform: (a: Int, b: R) -> V): List<V>

inline fun <R, V> LongArray.zip(other: Array<out R>, transform: (a: Long, b: R) -> V): List<V>

inline fun <V> LongArray.zip(other: LongArray, transform: (a: Long, b: Long) -> V): List<V>

inline fun <R, V> LongArray.zip(other: Iterable<R>, transform: (a: Long, b: R) -> V): List<V>

inline fun <R, V> ShortArray.zip(other: Array<out R>, transform: (a: Short, b: R) -> V): List<V>

inline fun <V> ShortArray.zip(other: ShortArray, transform: (a: Short, b: Short) -> V): List<V>

inline fun <R, V> ShortArray.zip(other: Iterable<R>, transform: (a: Short, b: R) -> V): List<V>

@ExperimentalUnsignedTypes

inline fun <R, V> UByteArray.zip(other: Array<out R>, transform: (a: UByte, b: R) -> V): List<V>

@ExperimentalUnsignedTypes

inline fun <V> UByteArray.zip(other: UByteArray, transform: (a: UByte, b: UByte) -> V): List<V>

@ExperimentalUnsignedTypes

inline fun <R, V> UByteArray.zip(other: Iterable<R>, transform: (a: UByte, b: R) -> V): List<V>

@ExperimentalUnsignedTypes

inline fun <R, V> UIntArray.zip(other: Array<out R>, transform: (a: UInt, b: R) -> V): List<V>

@ExperimentalUnsignedTypes

inline fun <V> UIntArray.zip(other: UIntArray, transform: (a: UInt, b: UInt) -> V): List<V>

@ExperimentalUnsignedTypes

inline fun <R, V> UIntArray.zip(other: Iterable<R>, transform: (a: UInt, b: R) -> V): List<V>

@ExperimentalUnsignedTypes

inline fun <R, V> ULongArray.zip(other: Array<out R>, transform: (a: ULong, b: R) -> V): List<V>

@ExperimentalUnsignedTypes

inline fun <V> ULongArray.zip(other: ULongArray, transform: (a: ULong, b: ULong) -> V): List<V>

@ExperimentalUnsignedTypes

inline fun <R, V> ULongArray.zip(other: Iterable<R>, transform: (a: ULong, b: R) -> V): List<V>

@ExperimentalUnsignedTypes

inline fun <R, V> UShortArray.zip(other: Array<out R>, transform: (a: UShort, b: R) -> V): List<V>

@ExperimentalUnsignedTypes

inline fun <V> UShortArray.zip(other: UShortArray, transform: (a: UShort, b: UShort) -> V): List<V>

@ExperimentalUnsignedTypes

inline fun <R, V> UShortArray.zip(other: Iterable<R>, transform: (a: UShort, b: R) -> V): List<V>

inline fun <T, R, V> Iterable<T>.zip(other: Array<out R>, transform: (a: T, b: R) -> V): List<V>

inline fun <T, R, V> Iterable<T>.zip(other: Iterable<R>, transform: (a: T, b: R) -> V): List<V>

zipWithNext

fun <T> Iterable<T>.zipWithNext(): List<Pair<T, T>>

inline fun <T, R> Iterable<T>.zipWithNext(transform: (a: T, b: T) -> R): List<R>

Properties

indices

val <T> Array<out T>.indices: IntRange

val BooleanArray.indices: IntRange

val ByteArray.indices: IntRange

val CharArray.indices: IntRange

val DoubleArray.indices: IntRange

val FloatArray.indices: IntRange

val IntArray.indices: IntRange

val LongArray.indices: IntRange

val ShortArray.indices: IntRange

@ExperimentalUnsignedTypes

val UByteArray.indices: IntRange

@ExperimentalUnsignedTypes

val UIntArray.indices: IntRange

@ExperimentalUnsignedTypes

val ULongArray.indices: IntRange

@ExperimentalUnsignedTypes

val UShortArray.indices: IntRange

val Collection<*>.indices: IntRange

lastIndex

val <T> Array<out T>.lastIndex: Int

val BooleanArray.lastIndex: Int

val ByteArray.lastIndex: Int

val CharArray.lastIndex: Int

val DoubleArray.lastIndex: Int

val FloatArray.lastIndex: Int

val IntArray.lastIndex: Int

val LongArray.lastIndex: Int

val ShortArray.lastIndex: Int

@ExperimentalUnsignedTypes

val UByteArray.lastIndex: Int

@ExperimentalUnsignedTypes

val UIntArray.lastIndex: Int

@ExperimentalUnsignedTypes

val ULongArray.lastIndex: Int

@ExperimentalUnsignedTypes

val UShortArray.lastIndex: Int

val <T> List<T>.lastIndex: Int